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

package/src/Api/Implementation/GridApiImpl.js

@@ -4,6 +4,7 @@ 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';
 export class GridApiImpl extends ApiBase {
     constructor(adaptable) {
         super(adaptable);
@@ -12,13 +13,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();
@@ -114,9 +120,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 +274,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 +335,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 +354,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 +457,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 +484,6 @@ export class GridApiImpl extends ApiBase {
     getRowCount() {
         return this.adaptable.getRowCount();
     }
-    getVisibleRowCount() {
-        return this.adaptable.getVisibleRowCount();
-    }
     getRowsInViewport() {
         return this.adaptable.getRowsInViewport();
     }
@@ -509,4 +511,8 @@ export class GridApiImpl extends ApiBase {
     getAgGridRowModelType() {
         return this.adaptable.getAgGridRowModelType();
     }
+    getVisibleRowCount() {
+        logDeprecation(this.adaptable.logger, 'GridApi', 'getVisibleRowCount', 'getRowCount');
+        return this.getRowCount();
+    }
 }

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/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,
+                suppressMenu: 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;
+    }
 }

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

@@ -24,9 +24,9 @@ import { AdaptableFrameworkComponent } from '../../AdaptableOptions/AdaptableFra
 import { IMetamodelService } from '../../Utilities/Services/Interface/IMetamodelService';
 import { IModuleCollection } from '../../Strategy/Interface/IModule';
 import { AdaptableObjectTag, AdaptableObjectWithScope } from '../../PredefinedConfig/Common/AdaptableObject';
-import { IRowEditService } from '../../Utilities/Services/Interface/IRowEditService';
 import { Fdc3Service } from '../../Utilities/Services/Fdc3Service';
 import { CellPopupService } from '../../Utilities/Services/CellPopupService';
+import { RowEditService } from '../../Utilities/Services/RowEditService';
 export declare class AdaptableInternalApi extends ApiBase {
     getSystemState(): SystemState;
     showPopupConfirmation(confirmation: UIConfirmation): void;
@@ -46,8 +46,7 @@ export declare class AdaptableInternalApi extends ApiBase {
     setPivotModeOn(): void;
     setPivotModeOff(): void;
     isGridInPivotMode(): boolean;
-    setTreeModeOn(): void;
-    setTreeModeOff(): void;
+    setTreeMode(mode: boolean): void;
     isGridInTreeMode(): boolean;
     getToolbarTitle(): string;
     buildDataChangedInfo(config: Pick<CellDataChangedInfo, 'newValue' | 'oldValue' | 'column' | 'primaryKeyValue' | 'rowNode' | 'trigger'>): CellDataChangedInfo;
@@ -65,7 +64,7 @@ export declare class AdaptableInternalApi extends ApiBase {
     getAlertService(): IAlertService;
     getTeamSharingService(): ITeamSharingService;
     getMetamodelService(): IMetamodelService;
-    getRowEditService(): IRowEditService;
+    getRowEditService(): RowEditService;
     getFdc3Service(): Fdc3Service;
     getModules(): IModuleCollection;
     getModuleFriendlyName(adaptableModule: AdaptableModule): string;

package/src/Api/Internal/AdaptableInternalApi.js

@@ -47,11 +47,13 @@ export class AdaptableInternalApi extends ApiBase {
     isGridInPivotMode() {
         return this.getAdaptableState().Grid.IsGridInPivotMode;
     }
-    setTreeModeOn() {
-        this.dispatchAction(GridRedux.SetTreeModeOn());
-    }
-    setTreeModeOff() {
-        this.dispatchAction(GridRedux.SetTreeModeOff());
+    setTreeMode(mode) {
+        if (!!mode) {
+            this.dispatchAction(GridRedux.SetTreeModeOn());
+        }
+        else {
+            this.dispatchAction(GridRedux.SetTreeModeOff());
+        }
     }
     isGridInTreeMode() {
         return this.getAdaptableState().Grid.IsGridInTreeMode;
@@ -219,13 +221,13 @@ export class AdaptableInternalApi extends ApiBase {
             frameworkComponent,
             componentType,
         });
-        if (this.adaptable.isInitialised) {
+        if (this.adaptable.isReady) {
             createComponentFn();
         }
         else {
             // adaptable may not be initialized yet if the framework component is part of the initial render
             // AFL 2021.10.14 - not really sure if this is necessary anymore?! (see the other changes in this commit)
-            waitForCondition(() => this.adaptable.isInitialised).then(() => {
+            waitForCondition(() => this.adaptable.isReady).then(() => {
                 createComponentFn();
             });
         }
@@ -448,7 +450,7 @@ export class AdaptableInternalApi extends ApiBase {
         var _a;
         let actionColumn;
         if (colDef.colId == ADAPTABLE_ROW_ACTION_BUTTONS) {
-            const actionButtons = this.adaptable.getActionRowButtonDefs();
+            const actionButtons = this.getActionRowApi().internalApi.getActionRowButtonDefs();
             actionColumn = {
                 columnId: ADAPTABLE_ROW_ACTION_BUTTONS,
                 actionColumnButton: actionButtons,

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

@@ -1,6 +1,7 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import { CalculatedColumn } from '../../PredefinedConfig/CalculatedColumnState';
 import { AdaptableColumn } from '../../types';
+import { ColDef } from '@ag-grid-community/core';
 export declare class CalculatedColumnInternalApi extends ApiBase {
     /**
      * Returns all the references in the AdaptableState of the given CalculatedColumn
@@ -27,4 +28,5 @@ export declare class CalculatedColumnInternalApi extends ApiBase {
     isQuantileAggregatedExpression(input: string): boolean;
     getExpressionFromCalculatedColumn(calculatedColumn: CalculatedColumn): string;
     fireCalculatedColumnChangedEvent(trigger: string, calculatedColumn: CalculatedColumn): void;
+    getColDefsForCalculatedColumns(): ColDef[];
 }

package/src/Api/Internal/CalculatedColumnInternalApi.js

@@ -1,4 +1,8 @@
 import { ApiBase } from '../Implementation/ApiBase';
+import { CreateEmptyCalculatedColumn } from '../../Utilities/ObjectFactory';
+import { AB_SPECIAL_COLUMN } from '../../Utilities/Constants/GeneralConstants';
+import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
+import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 export class CalculatedColumnInternalApi extends ApiBase {
     /**
      * Returns all the references in the AdaptableState of the given CalculatedColumn
@@ -87,4 +91,70 @@ export class CalculatedColumnInternalApi extends ApiBase {
         };
         this.adaptable.api.eventApi.emit('CalculatedColumnChanged', calculatedColumnChangedInfo);
     }
+    getColDefsForCalculatedColumns() {
+        const defaultCalculatedColumnSettings = CreateEmptyCalculatedColumn().CalculatedColumnSettings;
+        return this.getCalculatedColumnApi()
+            .getCalculatedColumns()
+            .map((calculatedColumn) => {
+            const calculatedColumnSettings = Object.assign(Object.assign({}, defaultCalculatedColumnSettings), calculatedColumn.CalculatedColumnSettings);
+            if (!calculatedColumnSettings.DataType) {
+                calculatedColumnSettings.DataType = this.getAdaptableApi()
+                    .internalApi.getAdaptableInstance()
+                    .CalculatedColumnExpressionService.getCalculatedColumnDataType(calculatedColumn.Query);
+            }
+            const columnTypes = [
+                AB_SPECIAL_COLUMN,
+                this.getGridApi().internalApi.getAgGridDataType(calculatedColumnSettings.DataType),
+            ];
+            if (ArrayExtensions.IsNotNullOrEmpty(calculatedColumnSettings.ColumnTypes)) {
+                columnTypes.push(...calculatedColumnSettings.ColumnTypes);
+            }
+            const isExternalEvaluation = !this.getExpressionApi().internalApi.evaluateExpressionInAdaptableQL('CalculatedColumn', calculatedColumn, this.getExpressionApi().getAdaptableQueryExpression(calculatedColumn.Query));
+            const valueGetter = (params) => {
+                var _a, _b;
+                if (isExternalEvaluation) {
+                    return (_a = params.data) === null || _a === void 0 ? void 0 : _a[calculatedColumn.ColumnId];
+                }
+                // if the grid data is NOT client side, we can aggregate only simple scalar expression (which depend on row data, not on other rows)
+                if (this.getGridApi().getAgGridRowModelType() !== 'clientSide' &&
+                    StringExtensions.IsNotNullOrEmpty(calculatedColumn.Query.AggregatedScalarExpression)) {
+                    return (_b = params.data) === null || _b === void 0 ? void 0 : _b[calculatedColumn.ColumnId];
+                }
+                return this.getAdaptableApi()
+                    .internalApi.getAdaptableInstance()
+                    .CalculatedColumnExpressionService.evaluateCalculatedColumnQuery(calculatedColumn, params.node);
+            };
+            const newColDef = {
+                headerName: calculatedColumn.FriendlyName
+                    ? calculatedColumn.FriendlyName
+                    : calculatedColumn.ColumnId,
+                colId: calculatedColumn.ColumnId,
+                hide: true,
+                editable: false,
+                width: calculatedColumnSettings.Width,
+                enableValue: calculatedColumnSettings.Aggregatable,
+                filter: calculatedColumnSettings.Filterable,
+                floatingFilter: calculatedColumnSettings.Filterable,
+                resizable: calculatedColumnSettings.Resizable,
+                enableRowGroup: calculatedColumnSettings.Groupable,
+                sortable: calculatedColumnSettings.Sortable,
+                enablePivot: calculatedColumnSettings.Pivotable,
+                suppressMenu: calculatedColumnSettings.SuppressMenu,
+                suppressMovable: calculatedColumnSettings.SuppressMovable,
+                type: columnTypes,
+                valueGetter,
+            };
+            if (calculatedColumnSettings.ShowToolTip != null &&
+                calculatedColumnSettings.ShowToolTip == true) {
+                newColDef.tooltipValueGetter = () => {
+                    return this.getAdaptableApi().internalApi.getAdaptableQueryExpressionText(calculatedColumn.Query);
+                };
+            }
+            if (calculatedColumnSettings.HeaderToolTip) {
+                newColDef.headerTooltip = calculatedColumnSettings.HeaderToolTip;
+            }
+            this.getAdaptableApi().logInfo('Setting up Calculated Column: ' + calculatedColumn.ColumnId);
+            return newColDef;
+        });
+    }
 }

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

@@ -56,4 +56,5 @@ export declare class ColumnFilterInternalApi extends ApiBase {
      */
     areColumnFiltersDifferent(oldFilters: ColumnFilter[], newFilters: ColumnFilter[]): boolean;
     getPredicateDefShortcuts(predicateDef: AdaptablePredicateDef): string[];
+    getFilterValuesMaxNumberOfItems(column: AdaptableColumn): number | undefined;
 }

package/src/Api/Internal/ColumnFilterInternalApi.js

@@ -171,7 +171,7 @@ export class ColumnFilterInternalApi extends ApiBase {
      * Fires Column Filter Applied Event - typically used to enable filtering on the server
      */
     fireColumnFilterAppliedEvent() {
-        if (this.adaptable.isLive) {
+        if (this.adaptable.isReady) {
             const adaptableApi = this.getAdaptableApi();
             const columnFilterAppliedInfo = {
                 columnFilters: this.getColumnFilterApi().getColumnFilters(),
@@ -202,4 +202,14 @@ export class ColumnFilterInternalApi extends ApiBase {
         }
         return predicateShortcuts;
     }
+    getFilterValuesMaxNumberOfItems(column) {
+        const maxFilterValues = this.getColumnFilterOptions().valuesFilterOptions.maxFilterValuesToDisplay;
+        if (typeof maxFilterValues === 'function') {
+            const columnFilterContext = Object.assign(Object.assign({}, this.getAdaptableApi().internalApi.buildBaseContext()), { column: column });
+            return maxFilterValues(columnFilterContext);
+        }
+        else {
+            return maxFilterValues;
+        }
+    }
 }

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

@@ -1,5 +1,7 @@
 import { ApiBase } from '../Implementation/ApiBase';
-import { Column } from '@ag-grid-community/core';
+import { Column, IRowNode } from '@ag-grid-community/core';
+import { CustomSort } from '../../PredefinedConfig/CustomSortState';
+import { ColumnValuesComparer } from '../../AdaptableOptions/CustomSortOptions';
 export declare class ColumnInternalApi extends ApiBase {
     /**
      * Retrieves 'ColumnType' property for a given Column
@@ -24,4 +26,5 @@ export declare class ColumnInternalApi extends ApiBase {
      */
     getAgGridColumnForAdaptableColumn(columnId: string): Column;
     isActionRowButtonColumn(columnId: string): boolean;
+    getActiveColumnComparator(columnId: string, customSort?: CustomSort, customSortComparer?: ColumnValuesComparer): (valueA: any, valueB: any, nodeA?: IRowNode, nodeB?: IRowNode, isInverted?: boolean) => number | undefined;
 }

package/src/Api/Internal/ColumnInternalApi.js

@@ -39,4 +39,16 @@ export class ColumnInternalApi extends ApiBase {
     isActionRowButtonColumn(columnId) {
         return columnId === ADAPTABLE_ROW_ACTION_BUTTONS;
     }
+    getActiveColumnComparator(columnId, customSort, customSortComparer) {
+        if ((!customSort || (customSort === null || customSort === void 0 ? void 0 : customSort.IsSuspended)) && !customSortComparer) {
+            // defaults to AG-Grid column definition comparator if no CustomSort is defined&active
+            const colDefComparator = this.adaptable.agGridColumnAdapter.getUserColDefProperty(columnId, 'comparator');
+            return colDefComparator;
+        }
+        // CustomSort Comparer function takes precedence over CustomSort SortedValues
+        const comparerFunction = customSortComparer
+            ? customSortComparer.comparer
+            : this.getCustomSortApi().internalApi.getDefaultCustomSortComparer(customSort.ColumnId, customSort.SortedValues);
+        return comparerFunction;
+    }
 }

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

@@ -1,6 +1,7 @@
 import { ApiBase } from '../Implementation/ApiBase';
-import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { ColumnValuesComparer } from '../../AdaptableOptions/CustomSortOptions';
+import { AdaptableComparerFunction } from '../../PredefinedConfig/Common/AdaptableComparerFunction';
 export declare class CustomSortInternalApi extends ApiBase {
-    getCustomSortComparer(column: AdaptableColumn): ColumnValuesComparer | undefined;
+    getCustomSortComparer(columnId: string): ColumnValuesComparer | undefined;
+    getDefaultCustomSortComparer(columnId: string, columnValues: any[]): AdaptableComparerFunction;
 }

package/src/Api/Internal/CustomSortInternalApi.js

@@ -1,7 +1,38 @@
 import { ApiBase } from '../Implementation/ApiBase';
 export class CustomSortInternalApi extends ApiBase {
-    getCustomSortComparer(column) {
+    getCustomSortComparer(columnId) {
         var _a;
+        const column = this.getColumnApi().getColumnWithColumnId(columnId);
         return (_a = this.getCustomSortOptions().customSortComparers) === null || _a === void 0 ? void 0 : _a.find((csc) => this.adaptable.api.scopeApi.isColumnInScope(column, csc.scope));
     }
+    getDefaultCustomSortComparer(columnId, columnValues) {
+        // have to return a function that may not have access to this
+        const adaptable = this.adaptable;
+        return function compareItemsOfCustomSort(valueA, valueB, nodeA, nodeB) {
+            var _a, _b;
+            let firstElementValueString = (_a = (nodeA && adaptable.getDisplayValueFromRowNode(nodeA, columnId))) !== null && _a !== void 0 ? _a : valueA;
+            let secondElementValueString = (_b = (nodeB && adaptable.getDisplayValueFromRowNode(nodeB, columnId))) !== null && _b !== void 0 ? _b : valueB;
+            let indexFirstElement = columnValues.indexOf(firstElementValueString);
+            let containsFirstElement = indexFirstElement >= 0;
+            let indexSecondElement = columnValues.indexOf(secondElementValueString);
+            let containsSecondElement = indexSecondElement >= 0;
+            //if none of the element are in the list we jsut return normal compare
+            if (!containsFirstElement && !containsSecondElement) {
+                if (valueA == valueB) {
+                    return 0;
+                }
+                return valueA < valueB ? -1 : 1;
+            }
+            //if first item not in the list make sure we put it after the second item
+            if (!containsFirstElement) {
+                return 1;
+            }
+            //if second item not in the list make sure we put it after the first item
+            if (!containsSecondElement) {
+                return -1;
+            }
+            //return the comparison from the list if the two items are in the list
+            return indexFirstElement - indexSecondElement;
+        };
+    }
 }

package/src/Api/Internal/DataSetInternalApi.js

@@ -5,7 +5,7 @@ export class DataSetInternalApi extends ApiBase {
      * @param dataSet Data Set which has been selected
      */
     fireDataSetSelectedEvent(dataSet) {
-        if (this.adaptable.isLive) {
+        if (this.adaptable.isReady) {
             const dataSetSelectedInfo = {
                 adaptableApi: this.adaptable.api,
                 dataSet,

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

@@ -1,6 +1,7 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { FreeTextColumn } from '../../PredefinedConfig/FreeTextColumnState';
+import { ColDef } from '@ag-grid-community/core';
 export declare class FreeTextColumnInternalApi extends ApiBase {
     /**
      * Checks if a User Edit was in a Free Text Column
@@ -12,4 +13,5 @@ export declare class FreeTextColumnInternalApi extends ApiBase {
      * @param freeTextColumn FreeTextColumn to be checked
      */
     getFreeTextColumnModuleReferences(freeTextColumn: FreeTextColumn): string[];
+    getColDefsForFreeTextColumns(): ColDef<any, any>[];
 }

package/src/Api/Internal/FreeTextColumnInternalApi.js

@@ -1,4 +1,9 @@
 import { ApiBase } from '../Implementation/ApiBase';
+import { CreateEmptyFreeTextColumn } from '../../Utilities/ObjectFactory';
+import { AdaptableNumberEditor } from '../../agGrid/editors/AdaptableNumberEditor';
+import { AdaptableDateEditor } from '../../agGrid/editors/AdaptableDateEditor';
+import { AB_SPECIAL_COLUMN } from '../../Utilities/Constants/GeneralConstants';
+import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 export class FreeTextColumnInternalApi extends ApiBase {
     /**
      * Checks if a User Edit was in a Free Text Column
@@ -37,4 +42,58 @@ export class FreeTextColumnInternalApi extends ApiBase {
         });
         return references;
     }
+    getColDefsForFreeTextColumns() {
+        const defaultFreeTextColumnSettings = CreateEmptyFreeTextColumn().FreeTextColumnSettings;
+        return this.getFreeTextColumnApi()
+            .getFreeTextColumns()
+            .map((freeTextColumn) => {
+            var _a;
+            const freeTextColumnSettings = Object.assign(Object.assign({}, defaultFreeTextColumnSettings), freeTextColumn.FreeTextColumnSettings);
+            const dataTypeEditor = freeTextColumnSettings.DataType === 'Number'
+                ? AdaptableNumberEditor
+                : freeTextColumnSettings.DataType === 'Date'
+                    ? AdaptableDateEditor
+                    : null;
+            const columnTypes = [
+                AB_SPECIAL_COLUMN,
+                this.getGridApi().internalApi.getAgGridDataType(freeTextColumnSettings.DataType),
+            ];
+            if (ArrayExtensions.IsNotNullOrEmpty((_a = freeTextColumn === null || freeTextColumn === void 0 ? void 0 : freeTextColumn.FreeTextColumnSettings) === null || _a === void 0 ? void 0 : _a.ColumnTypes)) {
+                columnTypes.push(...freeTextColumn.FreeTextColumnSettings.ColumnTypes);
+            }
+            const newColDef = {
+                headerName: freeTextColumn.FriendlyName || freeTextColumn.ColumnId,
+                colId: freeTextColumn.ColumnId,
+                editable: true,
+                hide: true,
+                width: freeTextColumnSettings.Width,
+                enableValue: freeTextColumnSettings.Aggregatable,
+                filter: freeTextColumnSettings.Filterable,
+                floatingFilter: freeTextColumnSettings.Filterable,
+                resizable: freeTextColumnSettings.Resizable,
+                enableRowGroup: freeTextColumnSettings.Groupable,
+                sortable: freeTextColumnSettings.Sortable,
+                enablePivot: freeTextColumnSettings.Pivotable,
+                suppressMenu: freeTextColumnSettings.SuppressMenu,
+                suppressMovable: freeTextColumnSettings.SuppressMovable,
+                cellEditor: dataTypeEditor !== null && dataTypeEditor !== void 0 ? dataTypeEditor : (freeTextColumn.TextEditor && freeTextColumn.TextEditor == 'Large'
+                    ? 'agLargeTextCellEditor'
+                    : 'agTextCellEditor'),
+                type: columnTypes,
+                valueSetter: (params) => {
+                    return (params.data[freeTextColumn.ColumnId] = params.newValue);
+                },
+                // use a Boolean Cell Data Type if the Free Text Column is boolean
+                cellDataType: freeTextColumnSettings.DataType && freeTextColumnSettings.DataType == 'Boolean'
+                    ? 'boolean'
+                    : undefined,
+                valueGetter: (params) => this.getFreeTextColumnApi().getFreeTextColumnValueForRowNode(freeTextColumn, params.node),
+            };
+            if (freeTextColumnSettings.HeaderToolTip) {
+                newColDef.headerTooltip = freeTextColumnSettings.HeaderToolTip;
+            }
+            this.getAdaptableApi().logInfo('Setting up FreeText Column: ' + freeTextColumn.ColumnId);
+            return newColDef;
+        });
+    }
 }