@adaptabletools/adaptable-cjs 17.0.0-canary.1

package/src/agGrid/agGridHelper.js

@@ -0,0 +1,679 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agGridHelper = void 0;
+const tslib_1 = require("tslib");
+const Uuid_1 = require("../PredefinedConfig/Uuid");
+const AlertModule_1 = require("../Strategy/AlertModule");
+const BulkUpdateModule_1 = require("../Strategy/BulkUpdateModule");
+const CalculatedColumnModule_1 = require("../Strategy/CalculatedColumnModule");
+const CellSummaryModule_1 = require("../Strategy/CellSummaryModule");
+const ChartingModule_1 = require("../Strategy/ChartingModule");
+const ColumnInfoModule_1 = require("../Strategy/ColumnInfoModule");
+const CustomSortModule_1 = require("../Strategy/CustomSortModule");
+const DashboardModule_1 = require("../Strategy/DashboardModule");
+const DataChangeHistoryModule_1 = require("../Strategy/DataChangeHistoryModule");
+const DataImportModule_1 = require("../Strategy/DataImportModule");
+const DataSetModule_1 = require("../Strategy/DataSetModule");
+const ExportModule_1 = require("../Strategy/ExportModule");
+const Fdc3Module_1 = require("../Strategy/Fdc3Module");
+const ColumnFilterModule_1 = require("../Strategy/ColumnFilterModule");
+const FlashingCellModule_1 = require("../Strategy/FlashingCellModule");
+const FormatColumnModule_1 = require("../Strategy/FormatColumnModule");
+const FreeTextColumnModule_1 = require("../Strategy/FreeTextColumnModule");
+const GridFilterModule_1 = require("../Strategy/GridFilterModule");
+const GridInfoModule_1 = require("../Strategy/GridInfoModule");
+const LayoutModule_1 = require("../Strategy/LayoutModule");
+const NamedQueryModule_1 = require("../Strategy/NamedQueryModule");
+const NotesModule_1 = require("../Strategy/NotesModule");
+const PlusMinusModule_1 = require("../Strategy/PlusMinusModule");
+const QuickSearchModule_1 = require("../Strategy/QuickSearchModule");
+const ScheduleModule_1 = require("../Strategy/ScheduleModule");
+const SettingsPanelModule_1 = require("../Strategy/SettingsPanelModule");
+const ShortcutModule_1 = require("../Strategy/ShortcutModule");
+const SmartEditModule_1 = require("../Strategy/SmartEditModule");
+const StateManagementModule_1 = require("../Strategy/StateManagementModule");
+const StatusBarModule_1 = require("../Strategy/StatusBarModule");
+const StyledColumnModule_1 = require("../Strategy/StyledColumnModule");
+const SystemStatusModule_1 = require("../Strategy/SystemStatusModule");
+const TeamSharingModule_1 = require("../Strategy/TeamSharingModule");
+const ThemeModule_1 = require("../Strategy/ThemeModule");
+const ToolPanelModule_1 = require("../Strategy/ToolPanelModule");
+const GeneralConstants = tslib_1.__importStar(require("../Utilities/Constants/GeneralConstants"));
+const GeneralConstants_1 = require("../Utilities/Constants/GeneralConstants");
+const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
+const ArrayExtensions_1 = require("../Utilities/Extensions/ArrayExtensions");
+const StringExtensions_1 = require("../Utilities/Extensions/StringExtensions");
+const Helper_1 = require("../Utilities/Helpers/Helper");
+const UIHelper_1 = tslib_1.__importDefault(require("../View/UIHelper"));
+const BadgeRenderer_1 = require("./BadgeRenderer");
+const PercentBarRenderer_1 = require("./PercentBarRenderer");
+const tinycolor = require('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
+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_1.DashboardModule(api));
+        modules.set(ModuleConstants.AlertModuleId, new AlertModule_1.AlertModule(api));
+        modules.set(ModuleConstants.FlashingCellModuleId, new FlashingCellModule_1.FlashingCellModule(api));
+        modules.set(ModuleConstants.BulkUpdateModuleId, new BulkUpdateModule_1.BulkUpdateModule(api));
+        modules.set(ModuleConstants.CalculatedColumnModuleId, new CalculatedColumnModule_1.CalculatedColumnModule(api));
+        modules.set(ModuleConstants.CellSummaryModuleId, new CellSummaryModule_1.CellSummaryModule(api));
+        modules.set(ModuleConstants.CustomSortModuleId, new CustomSortModule_1.CustomSortModule(api));
+        modules.set(ModuleConstants.DataChangeHistoryModuleId, new DataChangeHistoryModule_1.DataChangeHistoryModule(api));
+        modules.set(ModuleConstants.DataImportModuleId, new DataImportModule_1.DataImportModule(api));
+        modules.set(ModuleConstants.DataSetModuleId, new DataSetModule_1.DataSetModule(api));
+        modules.set(ModuleConstants.ExportModuleId, new ExportModule_1.ExportModule(api));
+        modules.set(ModuleConstants.ColumnFilterModuleId, new ColumnFilterModule_1.ColumnFilterModule(api));
+        modules.set(ModuleConstants.FormatColumnModuleId, new FormatColumnModule_1.FormatColumnModule(api));
+        modules.set(ModuleConstants.FreeTextColumnModuleId, new FreeTextColumnModule_1.FreeTextColumnModule(api));
+        modules.set(ModuleConstants.LayoutModuleId, new LayoutModule_1.LayoutModule(api));
+        modules.set(ModuleConstants.PlusMinusModuleId, new PlusMinusModule_1.PlusMinusModule(api));
+        modules.set(ModuleConstants.QuickSearchModuleId, new QuickSearchModule_1.QuickSearchModule(api));
+        modules.set(ModuleConstants.ScheduleModuleId, new ScheduleModule_1.ScheduleModule(api));
+        modules.set(ModuleConstants.SmartEditModuleId, new SmartEditModule_1.SmartEditModule(api));
+        modules.set(ModuleConstants.ShortcutModuleId, new ShortcutModule_1.ShortcutModule(api));
+        modules.set(ModuleConstants.StateManagementModuleId, new StateManagementModule_1.StateManagementModule(api));
+        modules.set(ModuleConstants.TeamSharingModuleId, new TeamSharingModule_1.TeamSharingModule(api));
+        modules.set(ModuleConstants.ToolPanelModuleId, new ToolPanelModule_1.ToolPanelModule(api));
+        modules.set(ModuleConstants.SystemStatusModuleId, new SystemStatusModule_1.SystemStatusModule(api));
+        modules.set(ModuleConstants.ThemeModuleId, new ThemeModule_1.ThemeModule(api));
+        modules.set(ModuleConstants.GridInfoModuleId, new GridInfoModule_1.GridInfoModule(api));
+        modules.set(ModuleConstants.ColumnInfoModuleId, new ColumnInfoModule_1.ColumnInfoModule(api));
+        modules.set(ModuleConstants.SettingsPanelModuleId, new SettingsPanelModule_1.SettingsPanelModule(api));
+        modules.set(ModuleConstants.StatusBarModuleId, new StatusBarModule_1.StatusBarModule(api));
+        modules.set(ModuleConstants.ChartingModuleId, new ChartingModule_1.ChartingModule(api));
+        modules.set(ModuleConstants.NotesModuleId, new NotesModule_1.NotesModule(api));
+        modules.set(ModuleConstants.StyledColumnModuleId, new StyledColumnModule_1.StyledColumnModule(api));
+        modules.set(ModuleConstants.Fdc3ModuleId, new Fdc3Module_1.Fdc3Module(api));
+        modules.set(ModuleConstants.GridFilterModuleId, new GridFilterModule_1.GridFilterModule(api));
+        modules.set(ModuleConstants.NamedQueryModuleId, new NamedQueryModule_1.NamedQueryModule(api));
+        return modules;
+    }
+    TrySetUpNodeIds(hasAutogeneratedPrimaryKey) {
+        if (StringExtensions_1.StringExtensions.IsNullOrEmpty(this.adaptable.adaptableOptions.primaryKey)) {
+            // if no valid pk then always false
+            return false;
+        }
+        if (Helper_1.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_1.Helper.objectNotExists(params.data[primaryKey])) {
+                    params.data[primaryKey] = (0, Uuid_1.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 (0, PercentBarRenderer_1.getPercentBarRendererForColumn)(styledColumn, abColumn, this.adaptable.api);
+    }
+    createBadgeRendererComp(styledColumn, abColumn) {
+        return (0, BadgeRenderer_1.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
+                    ? GeneralConstants_1.ADAPTABLE_ROW_ACTION_BUTTONS_FRIENDLY_NAME
+                    : isFdc3MainActionColumn
+                        ? GeneralConstants_1.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: (0, Uuid_1.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_1.default.getAdaptableToolPanelWidth(),
+            minWidth: UIHelper_1.default.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_1.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);
+        }
+    }
+    fireSelectionChangedEvent() {
+        let selectionChangedInfo = {
+            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('SelectionChanged', selectionChangedInfo);
+    }
+    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 === GeneralConstants_1.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 === GeneralConstants_1.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_1.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_1.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_1.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_1.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,
+                    };
+                }),
+            },
+        };
+    }
+}
+exports.agGridHelper = agGridHelper;