@adaptabletools/adaptable 18.0.0-canary.3 → 18.0.0-canary.30

package/src/agGrid/agGridHelper.js

@@ -1,686 +0,0 @@
-import { createUuid } from '../PredefinedConfig/Uuid';
-import { AlertModule } from '../Strategy/AlertModule';
-import { BulkUpdateModule } from '../Strategy/BulkUpdateModule';
-import { CalculatedColumnModule } from '../Strategy/CalculatedColumnModule';
-import { CellSummaryModule } from '../Strategy/CellSummaryModule';
-import { ChartingModule } from '../Strategy/ChartingModule';
-import { ColumnInfoModule } from '../Strategy/ColumnInfoModule';
-import { CustomSortModule } from '../Strategy/CustomSortModule';
-import { DashboardModule } from '../Strategy/DashboardModule';
-import { DataChangeHistoryModule } from '../Strategy/DataChangeHistoryModule';
-import { DataImportModule } from '../Strategy/DataImportModule';
-import { DataSetModule } from '../Strategy/DataSetModule';
-import { ExportModule } from '../Strategy/ExportModule';
-import { Fdc3Module } from '../Strategy/Fdc3Module';
-import { ColumnFilterModule } from '../Strategy/ColumnFilterModule';
-import { FlashingCellModule } from '../Strategy/FlashingCellModule';
-import { FormatColumnModule } from '../Strategy/FormatColumnModule';
-import { FreeTextColumnModule } from '../Strategy/FreeTextColumnModule';
-import { GridFilterModule } from '../Strategy/GridFilterModule';
-import { GridInfoModule } from '../Strategy/GridInfoModule';
-import { LayoutModule } from '../Strategy/LayoutModule';
-import { NamedQueryModule } from '../Strategy/NamedQueryModule';
-import { NotesModule } from '../Strategy/NotesModule';
-import { PlusMinusModule } from '../Strategy/PlusMinusModule';
-import { QuickSearchModule } from '../Strategy/QuickSearchModule';
-import { ScheduleModule } from '../Strategy/ScheduleModule';
-import { SettingsPanelModule } from '../Strategy/SettingsPanelModule';
-import { ShortcutModule } from '../Strategy/ShortcutModule';
-import { SmartEditModule } from '../Strategy/SmartEditModule';
-import { StateManagementModule } from '../Strategy/StateManagementModule';
-import { StatusBarModule } from '../Strategy/StatusBarModule';
-import { StyledColumnModule } from '../Strategy/StyledColumnModule';
-import { SystemStatusModule } from '../Strategy/SystemStatusModule';
-import { TeamSharingModule } from '../Strategy/TeamSharingModule';
-import { ThemeModule } from '../Strategy/ThemeModule';
-import { ToolPanelModule } from '../Strategy/ToolPanelModule';
-import * as GeneralConstants from '../Utilities/Constants/GeneralConstants';
-import { ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME, ADAPTABLE_ROW_ACTION_BUTTONS, ADAPTABLE_ROW_ACTION_BUTTONS_FRIENDLY_NAME, } from '../Utilities/Constants/GeneralConstants';
-import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
-import { ArrayExtensions } from '../Utilities/Extensions/ArrayExtensions';
-import { StringExtensions } from '../Utilities/Extensions/StringExtensions';
-import { Helper } from '../Utilities/Helpers/Helper';
-import UIHelper from '../View/UIHelper';
-import { getBadgeRendererForColumn } from './BadgeRenderer';
-import { getPercentBarRendererForColumn } from './PercentBarRenderer';
-import { CommentsModule } from '../Strategy/CommentsModule';
-import tinycolor from 'tinycolor2';
-/**
- * Adaptable AG Grid implementation is getting really big and unwieldy
- * So lets put some of the more obvious 'Helper' functions here
- * This is a bit crap - it should take a GridOptions object...
- */
-// tslint:disable-next-line: class-name
-export class agGridHelper {
-    constructor(adaptable, gridOptions) {
-        this.adaptable = adaptable;
-        this.gridOptions = gridOptions;
-        this.initialAgGridColDefs = {};
-    }
-    destroy() {
-        this.adaptable = null;
-        this.gridOptions = null;
-    }
-    getAgGridLightThemeName() {
-        // we try not to call these two methods, as we try to detect the default grid
-        // theme from the grid container element - users should set their aggrid theme in html, on the container element
-        // so we read it from there. if we don't find it there, we'll call this method, as a last resort.
-        return 'ag-theme-balham';
-    }
-    getAgGridDarkThemeName() {
-        return 'ag-theme-balham-dark';
-    }
-    setUpModules() {
-        const modules = new Map();
-        const api = this.adaptable.api;
-        // this is order is semi important as it currently decides the order of the  items in the Column Menu
-        // so we put Dashboard first and then the rest in alphabetical order with Grid Info last
-        modules.set(ModuleConstants.DashboardModuleId, new DashboardModule(api));
-        modules.set(ModuleConstants.AlertModuleId, new AlertModule(api));
-        modules.set(ModuleConstants.FlashingCellModuleId, new FlashingCellModule(api));
-        modules.set(ModuleConstants.BulkUpdateModuleId, new BulkUpdateModule(api));
-        modules.set(ModuleConstants.CalculatedColumnModuleId, new CalculatedColumnModule(api));
-        modules.set(ModuleConstants.CellSummaryModuleId, new CellSummaryModule(api));
-        modules.set(ModuleConstants.CustomSortModuleId, new CustomSortModule(api));
-        modules.set(ModuleConstants.DataChangeHistoryModuleId, new DataChangeHistoryModule(api));
-        modules.set(ModuleConstants.DataImportModuleId, new DataImportModule(api));
-        modules.set(ModuleConstants.DataSetModuleId, new DataSetModule(api));
-        modules.set(ModuleConstants.ExportModuleId, new ExportModule(api));
-        modules.set(ModuleConstants.ColumnFilterModuleId, new ColumnFilterModule(api));
-        modules.set(ModuleConstants.FormatColumnModuleId, new FormatColumnModule(api));
-        modules.set(ModuleConstants.FreeTextColumnModuleId, new FreeTextColumnModule(api));
-        modules.set(ModuleConstants.LayoutModuleId, new LayoutModule(api));
-        modules.set(ModuleConstants.PlusMinusModuleId, new PlusMinusModule(api));
-        modules.set(ModuleConstants.QuickSearchModuleId, new QuickSearchModule(api));
-        modules.set(ModuleConstants.ScheduleModuleId, new ScheduleModule(api));
-        modules.set(ModuleConstants.SmartEditModuleId, new SmartEditModule(api));
-        modules.set(ModuleConstants.ShortcutModuleId, new ShortcutModule(api));
-        modules.set(ModuleConstants.StateManagementModuleId, new StateManagementModule(api));
-        modules.set(ModuleConstants.TeamSharingModuleId, new TeamSharingModule(api));
-        modules.set(ModuleConstants.ToolPanelModuleId, new ToolPanelModule(api));
-        modules.set(ModuleConstants.SystemStatusModuleId, new SystemStatusModule(api));
-        modules.set(ModuleConstants.ThemeModuleId, new ThemeModule(api));
-        modules.set(ModuleConstants.GridInfoModuleId, new GridInfoModule(api));
-        modules.set(ModuleConstants.ColumnInfoModuleId, new ColumnInfoModule(api));
-        modules.set(ModuleConstants.SettingsPanelModuleId, new SettingsPanelModule(api));
-        modules.set(ModuleConstants.StatusBarModuleId, new StatusBarModule(api));
-        modules.set(ModuleConstants.ChartingModuleId, new ChartingModule(api));
-        modules.set(ModuleConstants.NotesModuleId, new NotesModule(api));
-        modules.set(ModuleConstants.StyledColumnModuleId, new StyledColumnModule(api));
-        modules.set(ModuleConstants.Fdc3ModuleId, new Fdc3Module(api));
-        modules.set(ModuleConstants.GridFilterModuleId, new GridFilterModule(api));
-        modules.set(ModuleConstants.NamedQueryModuleId, new NamedQueryModule(api));
-        modules.set(ModuleConstants.CommentsModuleId, new CommentsModule(api));
-        return modules;
-    }
-    TrySetUpNodeIds(hasAutogeneratedPrimaryKey) {
-        if (StringExtensions.IsNullOrEmpty(this.adaptable.adaptableOptions.primaryKey)) {
-            // if no valid pk then always false
-            return false;
-        }
-        if (Helper.objectExists(this.gridOptions.getRowId)) {
-            return true;
-        }
-        const primaryKey = this.adaptable.adaptableOptions.primaryKey;
-        if (hasAutogeneratedPrimaryKey) {
-            this.gridOptions.getRowId = (params) => {
-                // if the PK value is autogenerated, we need to make sure that the rowData has a valid PK value
-                // this should be taken care of in the Adaptable.[loadDataSource/setDataSource/updateRows]() methods, but the users will always make silly decisions
-                // so just to be safe we'll check here and add a PK value is missing
-                // thus adding a side-effect in a getter, but what can we do against it?! :)
-                if (Helper.objectNotExists(params.data[primaryKey])) {
-                    params.data[primaryKey] = createUuid();
-                }
-                return params.data[primaryKey];
-            };
-        }
-        else {
-            this.gridOptions.getRowId = (params) => {
-                var _a;
-                if (params.data[primaryKey]) {
-                    return params.data[primaryKey];
-                }
-                // row does not have primary key => might be a group row
-                const parentKeys = (_a = params.parentKeys) !== null && _a !== void 0 ? _a : [];
-                const values = Object.values(params.data);
-                if (values.length) {
-                    const id = [...parentKeys, values[0]].join('/');
-                    return id;
-                }
-            };
-        }
-        return true;
-    }
-    createPercentBarRendererComp(styledColumn, abColumn) {
-        return getPercentBarRendererForColumn(styledColumn, abColumn, this.adaptable.api);
-    }
-    createBadgeRendererComp(styledColumn, abColumn) {
-        return getBadgeRendererForColumn(styledColumn, abColumn, this.adaptable.api);
-    }
-    getCleanValue(value) {
-        if (typeof value === 'string') {
-            return value;
-        }
-        if (value == null || value == 'null' || value == undefined || value == 'undefined') {
-            return undefined;
-        }
-        return String(value) || '';
-    }
-    getRenderedValue(colDef, valueToRender) {
-        const render = colDef.cellRenderer;
-        if (typeof render === 'string') {
-            return this.getCleanValue(valueToRender);
-        }
-        return render({ value: valueToRender }) || '';
-    }
-    createAdaptableColumnFromAgGridColumn(agGridColumn, colsToGroups) {
-        const colId = agGridColumn.getColId();
-        const colDef = agGridColumn.getColDef();
-        const ColumnId = colId;
-        const pkColumn = this.adaptable.adaptableOptions.primaryKey;
-        const ColumnGroup = colsToGroups === null || colsToGroups === void 0 ? void 0 : colsToGroups[ColumnId];
-        const isRealColumnGroup = ColumnGroup
-            ? ColumnGroup.columnGroupId !== ColumnGroup.friendlyName
-            : false;
-        const isActionRowButtonColumn = this.adaptable.api.columnApi.internalApi.isActionRowButtonColumn(colId);
-        const isFdc3MainActionColumn = this.adaptable.api.fdc3Api.internalApi.isFdc3MainActionColumn(colId);
-        let friendlyName;
-        const colExists = this.adaptable.api.columnApi.doesColumnExist(ColumnId);
-        if (colExists) {
-            friendlyName = this.adaptable.api.columnApi.getFriendlyNameForColumnId(ColumnId);
-        }
-        else {
-            const displayName = this.gridOptions.columnApi.getDisplayNameForColumn(agGridColumn, 'header');
-            const columnFriendlyName = this.adaptable.adaptableOptions.columnOptions.columnFriendlyName;
-            const customFriendlyName = typeof columnFriendlyName === 'function'
-                ? columnFriendlyName({
-                    colId: colId,
-                    agColumn: agGridColumn,
-                    columnGroup: isRealColumnGroup ? ColumnGroup : undefined,
-                    displayName: displayName,
-                })
-                : null;
-            friendlyName =
-                customFriendlyName !== null && customFriendlyName !== void 0 ? customFriendlyName : (isActionRowButtonColumn
-                    ? ADAPTABLE_ROW_ACTION_BUTTONS_FRIENDLY_NAME
-                    : isFdc3MainActionColumn
-                        ? ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME
-                        : displayName);
-            // Add Column Group;s friendlyname to the Column Friendly Name if its in a legitimate Column Group
-            if (this.adaptable.adaptableOptions.columnOptions.addColumnGroupToColumnFriendlyName &&
-                colDef.columnGroupShow &&
-                ColumnGroup &&
-                ColumnGroup.columnGroupId !== ColumnGroup.friendlyName) {
-                friendlyName += ' [' + ColumnGroup.friendlyName + ']';
-            }
-        }
-        if (!this.initialAgGridColDefs[colId]) {
-            this.initialAgGridColDefs[colId] = Object.assign({}, agGridColumn.getUserProvidedColDef());
-        }
-        const dataType = this.getColumnDataType(agGridColumn, false);
-        const abColumn = {
-            Uuid: createUuid(),
-            columnId: ColumnId,
-            field: colDef.field,
-            friendlyName: friendlyName,
-            isPrimaryKey: ColumnId === pkColumn,
-            dataType: dataType,
-            visible: agGridColumn.isVisible(),
-            readOnly: this.isColumnReadonly(colDef),
-            columnGroup: ColumnGroup,
-            fieldOnly: this.isColumnFieldonly(colDef),
-            sortable: this.isColumnSortable(colDef),
-            filterable: this.isColumnFilterable(colDef),
-            groupable: this.isColumnRowGroupable(colDef),
-            pivotable: this.isColumnPivotable(colDef),
-            aggregatable: this.isColumnAggregetable(colDef),
-            availableAggregationFunctions: null,
-            aggregationFunction: null,
-            moveable: this.isColumnMoveable(colDef),
-            hideable: this.isColumnHideable(colDef),
-            queryable: this.isColumnQueryable(colDef, ColumnId, friendlyName, dataType),
-            exportable: this.isColumnExportable(colDef, ColumnId, friendlyName, dataType),
-            isGrouped: this.isColumnRowGrouped(colDef),
-            isFixed: this.isColumnFixed(colDef),
-            pinned: this.getColumnPinnedPosition(colDef),
-            isExcludedFromQuickSearch: false,
-            isSparkline: this.isColumnSparkline(colDef),
-        };
-        if (abColumn.aggregatable) {
-            abColumn.availableAggregationFunctions = this.getColumnAggregationFunctions(colDef);
-            if (typeof colDef.aggFunc === 'string') {
-                abColumn.aggregationFunction = colDef.aggFunc;
-            }
-        }
-        // lets set this here one as the function cannot change the result so dont need to run it each time
-        let excludeColumnFromQuickSearch = this.adaptable.adaptableOptions.quickSearchOptions.excludeColumnFromQuickSearch;
-        if (excludeColumnFromQuickSearch) {
-            if (excludeColumnFromQuickSearch(abColumn)) {
-                abColumn.isExcludedFromQuickSearch = true;
-            }
-        }
-        return abColumn;
-    }
-    buildAdaptableToolPanelDef() {
-        return {
-            id: GeneralConstants.ADAPTABLE_TOOLPANEL_ID,
-            toolPanel: GeneralConstants.ADAPTABLE_TOOLPANEL_COMPONENT,
-            labelDefault: GeneralConstants.ADAPTABLE,
-            labelKey: 'adaptable',
-            iconKey: 'menu',
-            width: UIHelper.getAdaptableToolPanelWidth(),
-            minWidth: UIHelper.getAdaptableToolPanelWidth(),
-            // maxWidth = undefined,
-        };
-    }
-    isSideBarDefObject(sidebarDef) {
-        return Array.isArray(sidebarDef === null || sidebarDef === void 0 ? void 0 : sidebarDef.toolPanels);
-    }
-    mapToolPanelDefs(toolPanelDefs = []) {
-        // if it's an alias for the adaptable tool panel, map it to a ToolPanelDef, otherwise return it as it is
-        return toolPanelDefs.map((toolPanelDef) => toolPanelDef === GeneralConstants.ADAPTABLE_TOOLPANEL_ID
-            ? this.buildAdaptableToolPanelDef()
-            : toolPanelDef);
-    }
-    // This method reselects cells - only IF they are in a single column
-    // Might be able to change that later
-    // We do this by gettng the selected cells, clearing the selection and then re-applying
-    reselectSelectedCells() {
-        const selectedCellRanges = this.gridOptions.api.getCellRanges();
-        if (ArrayExtensions.CorrectLength(selectedCellRanges, 1)) {
-            const selectedCellRange = selectedCellRanges[0];
-            const cellRangeParams = {
-                rowStartIndex: selectedCellRange.startRow.rowIndex,
-                rowEndIndex: selectedCellRange.endRow.rowIndex,
-                columns: selectedCellRange.columns,
-            };
-            this.gridOptions.api.clearRangeSelection();
-            this.gridOptions.api.addCellRange(cellRangeParams);
-        }
-    }
-    fireCellSelectionChangedEvent() {
-        let cellSelectionChangedInfo = {
-            adaptableApi: this.adaptable.api,
-            selectedCellInfo: this.adaptable.api.gridApi.getGridState().SelectedCellInfo,
-            //   selectedRowInfo: this.adaptable.api.gridApi.getGridState().SelectedRowInfo,
-            userName: this.adaptable.api.optionsApi.getUserName(),
-            adaptableId: this.adaptable.api.optionsApi.getAdaptableId(),
-        };
-        this.adaptable.api.eventApi.emit('CellSelectionChanged', cellSelectionChangedInfo);
-    }
-    fireRowSelectionChangedEvent() {
-        let rowSelectionChangedInfo = {
-            adaptableApi: this.adaptable.api,
-            //  selectedCellInfo: this.adaptable.api.gridApi.getGridState().SelectedCellInfo,
-            selectedRowInfo: this.adaptable.api.gridApi.getGridState().SelectedRowInfo,
-            userName: this.adaptable.api.optionsApi.getUserName(),
-            adaptableId: this.adaptable.api.optionsApi.getAdaptableId(),
-        };
-        this.adaptable.api.eventApi.emit('RowSelectionChanged', rowSelectionChangedInfo);
-    }
-    isColumnReadonly(colDef) {
-        // if the column has conditional/dynamic editability, we assume some rows may be editable
-        if (colDef && typeof colDef.editable === 'function') {
-            return false;
-        }
-        // otherwise we evaluate the colDef.editable property (columns are NOT editable by default)
-        return !colDef.editable;
-    }
-    isColumnFieldonly(colDef) {
-        if (colDef.hide == true && colDef.initialHide == true && colDef.lockVisible == true) {
-            return true;
-        }
-        return false;
-    }
-    isColumnSortable(colDef) {
-        if (colDef && colDef.sortable != null) {
-            return colDef.sortable;
-        }
-        return false;
-    }
-    isColumnRowGroupable(colDef) {
-        if (colDef && colDef.enableRowGroup != null) {
-            return colDef.enableRowGroup;
-        }
-        return false;
-    }
-    isColumnPivotable(colDef) {
-        if (colDef && colDef.enablePivot != null) {
-            return colDef.enablePivot;
-        }
-        return false;
-    }
-    isColumnAggregetable(colDef) {
-        if (colDef && colDef.enableValue != null) {
-            return colDef.enableValue;
-        }
-        return false;
-    }
-    getColumnAggregationFunctions(colDef) {
-        return colDef.allowedAggFuncs || ['sum', 'min', 'max', 'count', 'avg', 'first', 'last']; // those are the default fns aggrid supports out-of-the-box
-    }
-    isColumnMoveable(colDef) {
-        if (!colDef) {
-            return false;
-        }
-        if (colDef.suppressMovable != null && colDef.suppressMovable == true) {
-            return false;
-        }
-        if (this.isColumnFixed(colDef)) {
-            return false;
-        }
-        return true;
-    }
-    isColumnQueryable(colDef, columnId, friendlyName, datatype) {
-        if (!colDef) {
-            return false;
-        }
-        if (colDef.colId === ADAPTABLE_ROW_ACTION_BUTTONS) {
-            return false;
-        }
-        const abColumnBase = {
-            columnId: columnId,
-            friendlyName: friendlyName,
-            dataType: datatype,
-        };
-        return this.adaptable.api.expressionApi.isColumnQueryable(abColumnBase);
-    }
-    isColumnExportable(colDef, columnId, friendlyName, datatype) {
-        if (!colDef) {
-            return false;
-        }
-        if (colDef.colId === ADAPTABLE_ROW_ACTION_BUTTONS) {
-            return false;
-        }
-        const abColumnBase = {
-            columnId,
-            friendlyName,
-            dataType: datatype,
-        };
-        return this.adaptable.api.exportApi.isColumnExportable(abColumnBase);
-    }
-    isColumnHideable(colDef) {
-        if (!colDef) {
-            return false;
-        }
-        if (colDef.lockVisible != null && colDef.lockVisible == true) {
-            return false;
-        }
-        return true;
-    }
-    isColumnFilterable(colDef) {
-        // follow agGrid logic which is that ONLY filterable if explicitly set
-        if (this.adaptable.EntitlementService.getEntitlementAccessLevelForModule(ModuleConstants.ColumnFilterModuleId) == 'Hidden') {
-            return false;
-        }
-        return colDef != null && colDef.filter != null && colDef.filter != false;
-    }
-    getColumnPinnedPosition(colDef) {
-        return colDef.pinned
-            ? colDef.pinned === 'left' || colDef.pinned === true
-                ? 'left'
-                : 'right'
-            : false;
-    }
-    // used for AG Grid when the column is FixedPinned, meaning it should never be unpinned
-    isColumnFixed(colDef) {
-        if (!colDef) {
-            return false;
-        }
-        if (colDef.lockPosition != null && colDef.lockPosition == true) {
-            return true;
-        }
-        if (colDef.lockPinned != null && colDef.lockPinned == true) {
-            return true;
-        }
-        return false;
-    }
-    isColumnRowGrouped(colDef) {
-        if (!colDef) {
-            return false;
-        }
-        if (colDef.rowGroup != null && colDef.rowGroup == true) {
-            return true;
-        }
-        if (colDef.rowGroupIndex != null) {
-            return true;
-        }
-        return false;
-    }
-    isColumnSparkline(colDef) {
-        // see https://www.ag-grid.com/javascript-data-grid/sparklines-overview/#enabling-sparklines
-        return (colDef === null || colDef === void 0 ? void 0 : colDef.cellRenderer) === 'agSparklineCellRenderer';
-    }
-    getColumnDataType(column, logWarning = true) {
-        // Some columns can have no ID or Title. we return string as a consequence but it needs testing
-        if (!column) {
-            this.adaptable.logger.warn('column is undefined returning String for Type');
-            return 'String';
-        }
-        let dataType = 'Unknown';
-        // get the column type if already in store (and not unknown)
-        const existingColumn = this.adaptable.api.columnApi.getColumnWithColumnId(column.getId(), logWarning);
-        if (existingColumn && existingColumn.dataType != 'Unknown') {
-            return existingColumn.dataType;
-        }
-        // check for column type
-        const colType = column.getColDef().type;
-        if (colType) {
-            if (Array.isArray(colType)) {
-                colType.forEach((c) => {
-                    if (dataType == 'Unknown') {
-                        dataType = this.getAbColDefValue(c);
-                    }
-                });
-            }
-            else {
-                dataType = this.getAbColDefValue(colType);
-            }
-            if (dataType != 'Unknown') {
-                return dataType;
-            }
-        }
-        const model = this.gridOptions.api.getModel();
-        if (model == null) {
-            this.adaptable.logger.warn(`No model so returning type "Unknown" for Column: "${column.getColId()}"`);
-            return 'Unknown';
-        }
-        let row = model.getRow(0);
-        if (row == null) {
-            // possible that there will be no data.
-            this.adaptable.logger.warn(`No data in grid so returning type "Unknown" for Column: "${column.getColId()}"`);
-            return 'Unknown';
-        }
-        // if it's a group we need the content of the group
-        if (row.group) {
-            const childNodes = row.childrenAfterGroup;
-            if (ArrayExtensions.IsNullOrEmpty(childNodes)) {
-                this.adaptable.logger.warn(`No data in grid so returning type "Unknown" for Column: "${column.getColId()}"`);
-                return 'Unknown';
-            }
-            row = childNodes[0];
-        }
-        const value = this.gridOptions.api.getValue(column, row);
-        if (value instanceof Date) {
-            dataType = 'Date';
-        }
-        else if (Array.isArray(value) && value.length && typeof value[0] === 'number') {
-            dataType = 'Unknown';
-        }
-        else {
-            switch (typeof value) {
-                case 'string':
-                    dataType = 'String';
-                    break;
-                case 'number':
-                    dataType = 'Number';
-                    break;
-                case 'boolean':
-                    dataType = 'Boolean';
-                    break;
-                case 'object':
-                    dataType = 'Object';
-                    break;
-                default:
-                    break;
-            }
-        }
-        this.adaptable.logger.warn(`No defined type for column '${column.getColId()}'. Defaulting to type of first value: ${dataType}`);
-        return dataType;
-    }
-    getAbColDefValue(colType) {
-        if (colType == 'numericColumn') {
-            return 'Number';
-        }
-        if (colType.startsWith('abColDef')) {
-            const abColType = colType;
-            switch (abColType) {
-                case 'abColDefNumber':
-                    return 'Number';
-                case 'abColDefString':
-                    return 'String';
-                case 'abColDefBoolean':
-                    return 'Boolean';
-                case 'abColDefDate':
-                    return 'Date';
-                case 'abColDefObject':
-                    return 'Object';
-                case 'abColDefStringArray':
-                    return 'StringArray';
-                case 'abColDefNumberArray':
-                    return 'NumberArray';
-                case 'abColDefTupleNumberArray':
-                    return 'TupleNumberArray';
-                case 'abColDefObjectNumberArray':
-                    return 'ObjectNumberArray';
-                default:
-                    return 'Unknown';
-            }
-        }
-        return 'Unknown';
-    }
-    getAgGridDataType(dataType) {
-        if (!dataType) {
-            return 'abColDefString';
-        }
-        switch (dataType) {
-            case 'Boolean':
-                return 'abColDefBoolean';
-            case 'Date':
-                return 'abColDefDate';
-            case 'Number':
-                return 'abColDefNumber';
-            case 'Object':
-                return 'abColDefObject';
-            case 'String':
-                return 'abColDefString';
-            case 'NumberArray':
-                return 'abColDefNumberArray';
-            case 'TupleNumberArray':
-                return 'abColDefTupleNumberArray';
-            case 'ObjectNumberArray':
-                return 'abColDefObjectNumberArray';
-            default:
-                return 'abColDefCustom';
-        }
-    }
-    checkShouldClearExistingFiltersOrSearches() {
-        // if they have selected to clear column filters on startup then do it
-        if (this.adaptable.adaptableOptions.columnFilterOptions.clearColumnFiltersOnStartUp) {
-            if (ArrayExtensions.IsNotNullOrEmpty(this.adaptable.api.columnFilterApi.getColumnFilters())) {
-                this.adaptable.logger.warn('Clearing existing Column Filters as "clearColumnFiltersOnStartUp" is true');
-                this.adaptable.api.columnFilterApi.clearColumnFilters();
-            }
-        }
-        // if they have selected to clear the Grid filter on startup then do it
-        if (this.adaptable.adaptableOptions.gridFilterOptions.clearGridFilterOnStartUp) {
-            if (StringExtensions.IsNotNullOrEmpty(this.adaptable.api.gridFilterApi.getCurrentGridFilterExpression())) {
-                this.adaptable.logger.warn('Clearing existing Grid Filter as "clearGridFilterOnStartUp" is true');
-                this.adaptable.api.gridFilterApi.setGridFilterExpression('');
-            }
-        }
-        // if they have selected to clear searches on startup then do it
-        if (this.adaptable.adaptableOptions.quickSearchOptions.clearQuickSearchOnStartUp) {
-            if (StringExtensions.IsNotNullOrEmpty(this.adaptable.api.quickSearchApi.getQuickSearchState().QuickSearchText)) {
-                this.adaptable.logger.warn('Clearing existing Searches as "clearQuickSearchOnStartUp" is true');
-                this.adaptable.api.quickSearchApi.clearQuickSearch();
-            }
-        }
-    }
-    runAdaptableGroupComparerFunction() {
-        const adaptable = this.adaptable;
-        return function compareItemsOfCustomSort(params) {
-            const { nodeA, nodeB } = params;
-            let firstGroupedColumn = adaptable.getFirstGroupedColumn();
-            if (firstGroupedColumn) {
-                const definedColumnComparator = adaptable.getActiveColumnComparator(firstGroupedColumn.columnId, adaptable.api.customSortApi.getCustomSortForColumn(firstGroupedColumn.columnId), adaptable.api.customSortApi.internalApi.getCustomSortComparer(firstGroupedColumn));
-                if (definedColumnComparator) {
-                    return definedColumnComparator(nodeA.key, nodeB.key);
-                }
-                const sortOder = adaptable.api.layoutApi.getCurrentLayoutColumnSort(firstGroupedColumn.columnId);
-                if (sortOder === 'Desc') {
-                    return nodeA.key > nodeB.key ? -1 : 1;
-                }
-            }
-            // if no comparator available, just sort alphanumerically
-            if (nodeA.key == nodeB.key) {
-                return 0;
-            }
-            return nodeA.key < nodeB.key ? -1 : 1;
-        };
-    }
-    getCurrentIPPStyle() {
-        const headerFirstCol = document
-            .querySelectorAll('.ag-header-cell')
-            .item(0);
-        const header = document.querySelector('.ag-header');
-        const headerColStyle = header ? window.getComputedStyle(header, null) : null;
-        const firstRow = document.querySelector('.ag-row-even');
-        const firstRowStyle = firstRow ? window.getComputedStyle(firstRow, null) : null;
-        const secondRow = document.querySelector('.ag-row-odd');
-        const secondRowStyle = secondRow
-            ? window.getComputedStyle(secondRow, null)
-            : {
-                backgroundColor: '#fff',
-            };
-        return {
-            Header: {
-                headerColor: tinycolor(headerColStyle.color).toHexString(),
-                headerBackColor: tinycolor(headerColStyle.backgroundColor).toHexString(),
-                headerFontFamily: headerColStyle.fontFamily,
-                headerFontSize: headerColStyle.fontSize,
-                headerFontStyle: headerColStyle.fontStyle,
-                headerFontWeight: headerColStyle.fontWeight,
-                height: Number(headerColStyle.height.replace('px', '')),
-                Columns: this.adaptable.api.columnApi.getColumns().map((col) => {
-                    const headerColumn = document.querySelector(`.ag-header-cell[col-id='${col.columnId}']`);
-                    const headerColumnStyle = window.getComputedStyle(headerColumn || headerFirstCol, null);
-                    return {
-                        columnFriendlyName: col.friendlyName,
-                        width: Number(headerColumnStyle.width.replace('px', '')),
-                        textAlign: headerColumnStyle.textAlign,
-                    };
-                }),
-            },
-            Row: {
-                color: tinycolor(firstRowStyle.color).toHexString(),
-                backColor: tinycolor(firstRowStyle.backgroundColor).toHexString(),
-                altBackColor: tinycolor(secondRowStyle.backgroundColor).toHexString(),
-                fontFamily: firstRowStyle.fontFamily,
-                fontSize: firstRowStyle.fontSize,
-                fontStyle: firstRowStyle.fontStyle,
-                fontWeight: firstRowStyle.fontWeight,
-                height: Number(firstRowStyle.height.replace('px', '')),
-                Columns: this.adaptable.api.columnApi.getColumns().map((col) => {
-                    const cellElement = document.querySelector(`.ag-cell[col-id='${col.columnId}']`);
-                    const headerColumnStyle = window.getComputedStyle(cellElement || firstRow, null);
-                    return {
-                        columnFriendlyName: col.friendlyName,
-                        width: Number(headerColumnStyle.width.replace('px', '')),
-                        textAlign: headerColumnStyle.textAlign,
-                    };
-                }),
-            },
-        };
-    }
-}