@adaptabletools/adaptable 13.1.1 → 14.0.0-canary.1

package/src/Api/Internal/FormatColumnInternalApi.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatColumnInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const StringExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/StringExtensions"));
+const FormatHelper_1 = tslib_1.__importDefault(require("../../Utilities/Helpers/FormatHelper"));
+const ObjectFactory_1 = tslib_1.__importDefault(require("../../Utilities/ObjectFactory"));
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+class FormatColumnInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Retrieves all Format Columns in Adaptable State with the `Style` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithStyle() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => fc.Style);
+    }
+    /**
+     * Retrieves all Format Columns in Adaptable State with the `Style` or the `CellAlignment` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithStyleAndCellAlignment() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => fc.Style || fc.CellAlignment);
+    }
+    /**
+     * Retrieves all Format Columns in Adaptable State with `DisplayFormat` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithDisplayFormat() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => fc.DisplayFormat);
+    }
+    /**
+     * Retrieves all Format Columns in Adaptable State with `CellAlignment` property set
+     * @returns format columns
+     */
+    getAllFormatColumnWithCellAlignment() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => fc.CellAlignment);
+    }
+    /**
+     * Get all FormatColumns which are defined for this column and have a custom AdaptableStyle
+     * @param column
+     * @param config
+     * @returns list of FormatColumn
+     */
+    getFormatColumnsWithStyleForColumn(column, config) {
+        const formatColumns = this.getAllFormatColumnWithStyleAndCellAlignment().filter((formatColumn) => (config === null || config === void 0 ? void 0 : config.includeSuspended) || !formatColumn.IsSuspended);
+        return this.getFormatColumnWithColumnInScope(formatColumns, column);
+    }
+    /**
+     * Gets Format Column if any for given Column which includes Style element with ClassName
+     * @param column The Column for which to retrieve the Format Column
+     * @returns format columns
+     */
+    getFormatColumnWithStyleClassNameForColumn(column, config) {
+        return this.getFormatColumnsWithStyleForColumn(column, config).filter((formatColumn) => { var _a; return StringExtensions_1.default.IsNotNullOrEmpty((_a = formatColumn === null || formatColumn === void 0 ? void 0 : formatColumn.Style) === null || _a === void 0 ? void 0 : _a.ClassName); });
+    }
+    getFormatColumnWithColumnInScope(formatColumns, column) {
+        return this.getFormatColumnInColumnScope(formatColumns).filter((scopedFormatColumn) => this.adaptable.api.scopeApi.isColumnInScope(column, scopedFormatColumn.Scope));
+    }
+    // TODO is this really needed, I don't think it achieves anything
+    getFormatColumnInColumnScope(formatColumns) {
+        // we need to maintain the format columns order, therefore we will extract all 3 scope types in a single iteration
+        return formatColumns.filter((fc) => {
+            return (
+            // this.getFormatColumnsWithColumnScope(formatColumns)
+            this.adaptable.api.scopeApi.scopeHasColumns(fc.Scope) ||
+                // this.getFormatColumnsWithDataTypeScope(formatColumns)
+                this.adaptable.api.scopeApi.scopeHasDataType(fc.Scope) ||
+                // this.getFormatColumnsWithAllScope(formatColumns)
+                this.adaptable.api.scopeApi.scopeIsAll(fc.Scope));
+        });
+    }
+    /**
+     * Get all FormatColumns which are defined for this column and have a custom DisplayFormat
+     * @param column
+     * @param config
+     * @returns list of FormatColumn
+     */
+    getFormatColumnsWithDisplayFormatForColumn(column, config) {
+        const formatColumns = this.getAllFormatColumnWithDisplayFormat().filter((formatColumn) => (config === null || config === void 0 ? void 0 : config.includeSuspended) || !formatColumn.IsSuspended);
+        return this.getFormatColumnWithColumnInScope(formatColumns, column);
+    }
+    /**
+     * Format value according to format options.
+     *
+     * @param customDisplayFormatterContext context that includes value to format
+     * @param options formatter options
+     */
+    getNumberFormattedValue(value, node, abColumn, options) {
+        const preparedValue = this.applyCustomFormatters(value, node, abColumn, options);
+        return FormatHelper_1.default.NumberFormatter(preparedValue, options);
+    }
+    /**
+     * Format value according to format options.
+     *
+     * @param value  context that includes value to format
+     * @param options formatter options
+     */
+    getStringFormattedValue(value, node, abColumn, options) {
+        const preparedValue = this.applyCustomFormatters(value, node, abColumn, options);
+        return FormatHelper_1.default.StringFormatter(preparedValue, options);
+    }
+    /**
+     * Format value according to format options.
+     *
+     * @param customDisplayFormatterContext  context that includes value to format
+     * @param options formatter options
+     */
+    getDateFormattedValue(value, node, abColumn, options) {
+        const preparedValue = this.applyCustomFormatters(value, node, abColumn, options);
+        const dateFormatterOptions = options;
+        // only use DateFormatter if we have a pattern
+        return dateFormatterOptions.Pattern
+            ? FormatHelper_1.default.DateFormatter(preparedValue, options)
+            : preparedValue;
+    }
+    applyCustomFormatters(value, node, abColumn, options) {
+        var _a, _b, _c;
+        const columnCustomFormatters = (_a = options === null || options === void 0 ? void 0 : options.CustomDisplayFormats) !== null && _a !== void 0 ? _a : [];
+        if (!(columnCustomFormatters === null || columnCustomFormatters === void 0 ? void 0 : columnCustomFormatters.length)) {
+            return value;
+        }
+        const adaptableOptions = this.adaptable.adaptableOptions;
+        const customFormattersFromOptions = (_c = (_b = adaptableOptions === null || adaptableOptions === void 0 ? void 0 : adaptableOptions.userInterfaceOptions) === null || _b === void 0 ? void 0 : _b.customDisplayFormatters) !== null && _c !== void 0 ? _c : [];
+        // formatters are applied in the order they are defined in the options
+        const customFormatters = customFormattersFromOptions.filter((customFormatterOption) => columnCustomFormatters.includes(customFormatterOption.id));
+        const customDisplayFormatterContext = ObjectFactory_1.default.CreateCustomDisplayFormatterContext(value, node, abColumn, this.getAdaptableApi());
+        return customFormatters.reduce((context, formatter) => {
+            if (formatter && formatter.handler) {
+                return formatter.handler(context);
+            }
+            return context.cellValue;
+        }, customDisplayFormatterContext);
+    }
+    /**
+     * Returns all Predicates appropriate for the given Scope
+     * @param scope Scope to check
+     */
+    getFormatColumnDefsForScope(scope) {
+        return this.getAdaptableApi()
+            .predicateApi.internalApi.getFormatColumnPredicateDefs()
+            .filter((predicateDef) => this.adaptable.api.scopeApi.isScopeInScope(scope, predicateDef.columnScope));
+    }
+    /**
+     * Checks if format column is relevant for a given cell (intersection of given AdaptableColumn and RowNode)
+     *
+     * @param formatColumn
+     * @param column
+     * @param params
+     */
+    isFormatColumnRelevantForColumn(formatColumn, column, params) {
+        var _a, _b;
+        // suspended is important to be first
+        if (formatColumn.IsSuspended) {
+            return false;
+        }
+        if (!formatColumn.IncludeGroupedRows &&
+            this.adaptable.api.gridApi.isGroupRowNode(params.node)) {
+            return false;
+        }
+        if (!formatColumn.Rule) {
+            return true;
+        }
+        // first run the predicate
+        if (formatColumn.Rule.Predicates && ((_b = (_a = formatColumn.Rule) === null || _a === void 0 ? void 0 : _a.Predicates) === null || _b === void 0 ? void 0 : _b.length)) {
+            return this.evaluatePredicate({
+                formatColumn,
+                column,
+                value: params.value,
+                node: params.node,
+            });
+        }
+        else if (formatColumn.Rule.BooleanExpression) {
+            return this.evaluateExpression(formatColumn, params.node);
+        }
+        // nothing has passed then return false
+        return false;
+    }
+    evaluatePredicate({ formatColumn, column, value, node, }) {
+        var _a;
+        const params = {
+            value: value,
+            oldValue: null,
+            displayValue: value,
+            node: node,
+            column: column,
+        };
+        return this.adaptable.api.predicateApi.handlePredicates((_a = formatColumn.Rule) === null || _a === void 0 ? void 0 : _a.Predicates, params, false);
+    }
+    evaluateExpression(formatColumn, node) {
+        const isValidExpression = this.adaptable.api.queryLanguageApi.isValidBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, `Invalid format column rule '${formatColumn.Rule.BooleanExpression}'`);
+        return (isValidExpression &&
+            this.adaptable.api.internalApi
+                .getQueryLanguageService()
+                .evaluateBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, node));
+    }
+    /**
+     * Extract from the given FormatColumns only the ones which are relevant for a given cell (intersection of given AdaptableColumn and RowNode)
+     *
+     * @param formatColumns
+     * @param column
+     * @param params
+     */
+    getFormatColumnsRelevantForColumn(formatColumns, column, params) {
+        return formatColumns.filter((formatColumn) => this.isFormatColumnRelevantForColumn(formatColumn, column, params));
+    }
+    /**
+     * Retrieves all Format Columns which have an Expression
+     * @returns Format Columns with Expression
+     */
+    getFormatColumnsWithExpression() {
+        return this.getFormatColumnApi()
+            .getFormatColumns()
+            .filter((fc) => { var _a; return !!((_a = fc.Rule) === null || _a === void 0 ? void 0 : _a.BooleanExpression); });
+    }
+}
+exports.FormatColumnInternalApi = FormatColumnInternalApi;

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

@@ -0,0 +1,15 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { FreeTextColumn } from '../../PredefinedConfig/FreeTextColumnState';
+export declare class FreeTextColumnInternalApi extends ApiBase {
+    /**
+     * Checks if a User Edit was in a Free Text Column
+     * @param cellDataChangedInfo change to check
+     */
+    handleFreeTextColumnDataChange(cellDataChangedInfo: CellDataChangedInfo): void;
+    /**
+     * Returns all the references in the AdaptableState of the given FreeTextColumn
+     * @param freeTextColumn FreeTextColumn to be checked
+     */
+    getFreeTextColumnModuleReferences(freeTextColumn: FreeTextColumn): string[];
+}

package/src/Api/Internal/FreeTextColumnInternalApi.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeTextColumnInternalApi = void 0;
+const ApiBase_1 = require("../Implementation/ApiBase");
+class FreeTextColumnInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Checks if a User Edit was in a Free Text Column
+     * @param cellDataChangedInfo change to check
+     */
+    handleFreeTextColumnDataChange(cellDataChangedInfo) {
+        let freeTextColumn = this.getFreeTextColumnApi()
+            .getFreeTextColumns()
+            .find((fc) => fc.ColumnId == cellDataChangedInfo.column.columnId);
+        if (freeTextColumn) {
+            let freeTextStoredValue = {
+                PrimaryKey: cellDataChangedInfo.primaryKeyValue,
+                FreeText: cellDataChangedInfo.newValue,
+            };
+            this.getFreeTextColumnApi().setStoredValue(freeTextColumn.ColumnId, freeTextStoredValue);
+            var colsToRefresh = [cellDataChangedInfo.column.columnId];
+            const refencedCalcColumns = this.adaptable.api.calculatedColumnApi.internalApi.getCalculatedColumnsReferencingColumnId(cellDataChangedInfo.column.columnId);
+            refencedCalcColumns.forEach((calculatedColumn) => {
+                colsToRefresh.push(calculatedColumn.ColumnId);
+            });
+            this.adaptable.refreshCells([cellDataChangedInfo.rowNode], colsToRefresh, false);
+        }
+    }
+    /**
+     * Returns all the references in the AdaptableState of the given FreeTextColumn
+     * @param freeTextColumn FreeTextColumn to be checked
+     */
+    getFreeTextColumnModuleReferences(freeTextColumn) {
+        const references = [];
+        this.adaptable.adaptableModules.forEach((module) => {
+            if (module
+                .getModuleFreeTextColumnReferences()
+                .some((moduleReference) => moduleReference.Uuid === freeTextColumn.Uuid)) {
+                references.push(module.moduleInfo.FriendlyName);
+            }
+        });
+        return references;
+    }
+}
+exports.FreeTextColumnInternalApi = FreeTextColumnInternalApi;

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

@@ -0,0 +1,82 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { RowNode } from '@ag-grid-community/core';
+import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
+import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
+import { SelectedCellInfo } from '../../PredefinedConfig/Selection/SelectedCellInfo';
+import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInfo';
+import { AdaptableMenuItem } from '../../PredefinedConfig/Common/Menu';
+import { EditLookUpPermittedValues } from '../../AdaptableOptions/UserInterfaceOptions';
+export declare class GridInternalApi extends ApiBase {
+    /**
+     * Fires Grid Sorted Event
+     */
+    fireGridSortedEvent(): void;
+    /**
+     * Fires Cell Changed Changed Event - when any data in AG Grid's dataset has changed
+     */
+    fireCellChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
+    /**
+     * Fires Grid Data Changed Event - when a row has changed in AG Grid
+     */
+    fireGridDataChangedEvent(dataRows: any[], rowNodes: RowNode[], rowTrigger: 'Add' | 'Edit' | 'Delete'): void;
+    /**
+     * Gets all distinct display values in the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    getDistinctDisplayValuesForColumn(columnId: string): any[];
+    /**
+     * Gets all distinct Filter values for the Column with the given ColumnId (used for Floating Filter and Column Header filter)
+     * @param columnId Column to check
+     * @param columnFilter Current applied filter
+     */
+    getDistinctFilterDisplayValuesForColumn(columnId: string, filter: string, showFilteredRowsOnly: boolean): Promise<{
+        values: {
+            value: any;
+            label: string;
+        }[];
+        suppressClientSideFilter: boolean;
+    }>;
+    /**
+     * Gets all distinct Custom Sort values for the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    getDistinctCustomSortDisplayValuesForColumn(columnId: string): Promise<any[]>;
+    /**
+     * Gets all distinct Bulk Update values for the Column with the given ColumnId
+     * @param columnId Column to check
+     * @param selectedGridCells Selected grid cells
+     */
+    getDistinctBulkUpdateDisplayValuesForColumn(columnId: string, selectedGridCells: GridCell[]): Promise<any[]>;
+    /**
+     * Gets all distinct visible (after current filters are applied) display values in the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    getDistinctVisibleDisplayValuesForColumn(columnId: string): any[];
+    /**
+     * Gets all distinct raw values in Column. Values are sorted.
+     * @param columnId Column to check
+     * @param skipRowNode optional RowNode which should be skipped when collecting the distinct rawValues
+     */
+    getDistinctRawValuesForColumn(columnId: string, skipRowNode?: RowNode): any[];
+    /**
+     * Gets all distinct raw values in Column. Values are un-sorted.
+     * @param columnId Column to check
+     * @param skipRowNode optional RowNode which should be skipped when collecting the distinct rawValues
+     */
+    getUnsortedDistinctRawValuesForColumn(columnId: string, skipRowNode?: RowNode): any[];
+    /**
+     * Gets all distinct visible raw values in the Column
+     * @param columnId Column to check
+     */
+    getDistinctVisibleRawValuesForColumn(columnId: string): any[];
+    private sortDistinctValues;
+    setColumns(columns: AdaptableColumn[]): void;
+    setSelectedCells(selectedCellInfo: SelectedCellInfo): void;
+    setSelectedRows(selectedRowInfo: SelectedRowInfo): void;
+    setGridCell(gridCell: GridCell): void;
+    setGridCells(gridCells: GridCell[]): void;
+    private createDataChangedInfoFromGridCell;
+    buildStandaloneColumnHeader(column: AdaptableColumn): AdaptableMenuItem[];
+    getEditLookUpValuesForColumn(editLookUpItem: EditLookUpPermittedValues, column: AdaptableColumn, gridCell?: GridCell): any[] | undefined;
+}

package/src/Api/Internal/GridInternalApi.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridInternalApi = void 0;
+const tslib_1 = require("tslib");
+const ApiBase_1 = require("../Implementation/ApiBase");
+const Enums_1 = require("../../PredefinedConfig/Common/Enums");
+const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
+const GridRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/GridRedux"));
+class GridInternalApi extends ApiBase_1.ApiBase {
+    /**
+     * Fires Grid Sorted Event
+     */
+    fireGridSortedEvent() {
+        if (this.adaptable.isLive) {
+            const adaptableSortState = this.adaptable.api.configApi.getAdaptableSortState();
+            const adaptableApi = this.getAdaptableApi();
+            const gridSortedInfo = {
+                adaptableSortState: adaptableSortState,
+                adaptableApi: adaptableApi,
+            };
+            adaptableApi.eventApi.emit('GridSorted', gridSortedInfo);
+        }
+    }
+    /**
+     * Fires Cell Changed Changed Event - when any data in AG Grid's dataset has changed
+     */
+    fireCellChangedEvent(cellDataChangedInfo) {
+        if (this.adaptable.isLive) {
+            const cellChangedInfo = {
+                adaptableApi: this.adaptable.api,
+                cellChange: cellDataChangedInfo,
+            };
+            this.adaptable.api.eventApi.emit('CellChanged', cellChangedInfo);
+        }
+    }
+    /**
+     * Fires Grid Data Changed Event - when a row has changed in AG Grid
+     */
+    fireGridDataChangedEvent(dataRows, rowNodes, rowTrigger) {
+        if (this.adaptable.isLive) {
+            const gridDataChangedInfo = {
+                changedAt: Date.now(),
+                adaptableApi: this.adaptable.api,
+                rowTrigger,
+                dataRows,
+                rowNodes,
+            };
+            this.adaptable.api.eventApi.emit('GridDataChanged', gridDataChangedInfo);
+        }
+    }
+    /**
+     * Gets all distinct display values in the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    getDistinctDisplayValuesForColumn(columnId) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const returnValues = this.adaptable.getDistinctValuesForColumn(abColumn, false);
+        return this.sortDistinctValues(returnValues, abColumn).map((cv) => {
+            return cv.normalisedValue;
+        });
+    }
+    /**
+     * Gets all distinct Filter values for the Column with the given ColumnId (used for Floating Filter and Column Header filter)
+     * @param columnId Column to check
+     * @param columnFilter Current applied filter
+     */
+    async getDistinctFilterDisplayValuesForColumn(columnId, filter, showFilteredRowsOnly) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return {
+                values: [],
+                suppressClientSideFilter: false,
+            };
+        }
+        const { gridCells, suppressClientSideFilter } = await this.adaptable.getDistinctFilterValuesForColumn(abColumn, showFilteredRowsOnly, filter);
+        return {
+            values: this.sortDistinctValues(gridCells, abColumn).map((cv) => {
+                return {
+                    label: cv.displayValue,
+                    value: cv.normalisedValue,
+                };
+            }),
+            suppressClientSideFilter,
+        };
+    }
+    /**
+     * Gets all distinct Custom Sort values for the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    async getDistinctCustomSortDisplayValuesForColumn(columnId) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const gridCells = await this.adaptable.getDistinctCustomSortValuesForColumn(abColumn, false);
+        return this.sortDistinctValues(gridCells, abColumn).map((cv) => {
+            return cv.normalisedValue;
+        });
+    }
+    /**
+     * Gets all distinct Bulk Update values for the Column with the given ColumnId
+     * @param columnId Column to check
+     * @param selectedGridCells Selected grid cells
+     */
+    async getDistinctBulkUpdateDisplayValuesForColumn(columnId, selectedGridCells) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const gridCells = await this.adaptable.getDistinctBulkUpdateValuesForColumn(abColumn, false, selectedGridCells);
+        return this.sortDistinctValues(gridCells, abColumn).map((cv) => {
+            return cv.normalisedValue;
+        });
+    }
+    /**
+     * Gets all distinct visible (after current filters are applied) display values in the Column with the given ColumnId
+     * @param columnId Column to check
+     */
+    getDistinctVisibleDisplayValuesForColumn(columnId) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const returnValues = this.adaptable.getDistinctValuesForColumn(abColumn, true);
+        return this.sortDistinctValues(returnValues, abColumn).map((cv) => {
+            return cv.normalisedValue;
+        });
+    }
+    /**
+     * Gets all distinct raw values in Column. Values are sorted.
+     * @param columnId Column to check
+     * @param skipRowNode optional RowNode which should be skipped when collecting the distinct rawValues
+     */
+    getDistinctRawValuesForColumn(columnId, skipRowNode) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        return this.sortDistinctValues(this.getUnsortedDistinctRawValuesForColumn(columnId, skipRowNode), abColumn).map((cv) => {
+            return cv.rawValue;
+        });
+    }
+    /**
+     * Gets all distinct raw values in Column. Values are un-sorted.
+     * @param columnId Column to check
+     * @param skipRowNode optional RowNode which should be skipped when collecting the distinct rawValues
+     */
+    getUnsortedDistinctRawValuesForColumn(columnId, skipRowNode) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        return this.adaptable.getDistinctValuesForColumn(abColumn, false, skipRowNode);
+    }
+    /**
+     * Gets all distinct visible raw values in the Column
+     * @param columnId Column to check
+     */
+    getDistinctVisibleRawValuesForColumn(columnId) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (abColumn == undefined) {
+            return [];
+        }
+        const returnValues = this.adaptable.getDistinctValuesForColumn(abColumn, true);
+        return this.sortDistinctValues(returnValues, abColumn).map((cv) => {
+            return cv.rawValue;
+        });
+    }
+    sortDistinctValues(returnValues, column) {
+        // this does NOT into account Custom Sort - far too hard for now...
+        let sortOrder = Enums_1.SortOrder.Asc;
+        if (this.getFilterOptions().sortColumnValuesInFilter) {
+            let columnSort = this.adaptable.api.gridApi.getColumnSortForColumn(column.columnId);
+            if (columnSort && columnSort.SortOrder == 'Desc') {
+                sortOrder = Enums_1.SortOrder.Desc;
+            }
+        }
+        if (this.getColumnApi().hasNumberDataType(column === null || column === void 0 ? void 0 : column.columnId)) {
+            returnValues = ArrayExtensions_1.default.sortCellValueArrayNumeric(returnValues, sortOrder);
+        }
+        else if (this.getColumnApi().hasDateDataType(column === null || column === void 0 ? void 0 : column.columnId)) {
+            returnValues = ArrayExtensions_1.default.sortCellValueArrayDates(returnValues, sortOrder);
+        }
+        else {
+            returnValues = ArrayExtensions_1.default.sortCellValueArray(returnValues, sortOrder);
+        }
+        return returnValues;
+    }
+    setColumns(columns) {
+        this.dispatchAction(GridRedux.GridSetColumns(columns));
+    }
+    setSelectedCells(selectedCellInfo) {
+        this.dispatchAction(GridRedux.GridSetSelectedCells(selectedCellInfo));
+    }
+    setSelectedRows(selectedRowInfo) {
+        this.dispatchAction(GridRedux.GridSetSelectedRows(selectedRowInfo));
+    }
+    setGridCell(gridCell) {
+        const cellDataChangedInfo = this.createDataChangedInfoFromGridCell(gridCell);
+        this.adaptable.setCellValue(cellDataChangedInfo);
+    }
+    setGridCells(gridCells) {
+        if (ArrayExtensions_1.default.IsNotNullOrEmpty(gridCells)) {
+            gridCells.forEach((gc) => {
+                this.setGridCell(gc);
+            });
+        }
+    }
+    createDataChangedInfoFromGridCell(gridCell) {
+        let currentValue = this.adaptable.getDisplayValue(gridCell.primaryKeyValue, gridCell.column.columnId);
+        const currentRowNode = this.adaptable.getRowNodeForPrimaryKey(gridCell.primaryKeyValue);
+        const cellDataChangedInfo = this.getAdaptableApi().internalApi.buildDataChangedInfo({
+            oldValue: currentValue,
+            newValue: gridCell.rawValue,
+            column: gridCell.column,
+            primaryKeyValue: gridCell.primaryKeyValue,
+            rowNode: currentRowNode,
+        });
+        return cellDataChangedInfo;
+    }
+    buildStandaloneColumnHeader(column) {
+        return this.adaptable.buildStandaloneColumnHeader(column);
+    }
+    getEditLookUpValuesForColumn(editLookUpItem, column, gridCell) {
+        if (!editLookUpItem || !column) {
+            return undefined;
+        }
+        let editLookUpValues = editLookUpItem.values;
+        // first do the function then get hardcoded items
+        if (editLookUpValues != null && typeof editLookUpValues === 'function') {
+            const editLookUpContext = {
+                adaptableApi: this.adaptable.api,
+                column: column,
+                gridCell,
+            };
+            return editLookUpValues(editLookUpContext);
+        }
+        else {
+            let arr = editLookUpValues;
+            if (arr && ArrayExtensions_1.default.IsNotNullOrEmpty(arr)) {
+                return arr;
+            }
+        }
+        // if no hard-coded values or function provided then just get the distinct values for the column
+        // this will use the columnApi method that first looks for permitted values and then distinct values
+        return this.getDistinctDisplayValuesForColumn(column.columnId);
+    }
+}
+exports.GridInternalApi = GridInternalApi;

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

@@ -0,0 +1,48 @@
+import { ApiBase } from '../Implementation/ApiBase';
+import { Layout, LayoutState } from '../../PredefinedConfig/LayoutState';
+import { LayoutAssociatedObject } from '../../AdaptableOptions/LayoutOptions';
+import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
+export declare class LayoutInternalApi extends ApiBase {
+    /**
+     * Fires the `LayoutChanged` event
+     * @param trigger what caused event to fire
+     * @param oldSate Layout State before change
+     * @param newState Layout State after change
+     */
+    fireLayoutChangedEvent(trigger: string, oldSate: LayoutState, newState: LayoutState, skipEqualityCheck?: boolean): void;
+    /**
+     * Compares 2 Layouts for equality
+     * @param layout1 First Layout
+     * @param layout2 Second Layout
+     */
+    areLayoutsEqual(layout1: Layout, layout2: Layout): boolean;
+    /**
+     * Creates a Default Layout (when none provided in Config)
+     * @returns layout
+     */
+    createDefaultLayoutIfNeeded(): Layout | null;
+    /**
+     * Returns true if Layouts will contain Expanded Row Groups information
+     */
+    areExpandedRowGroupsSavedInLayouts(): boolean;
+    /**
+     * Checks if the draft layout and the current layout are the same.
+     * Useful when `autoSaveLayouts=true`
+     */
+    areDraftAndCurrentLayoutEqual(): boolean;
+    /**
+     * Returns what the layout supports.
+     * This takes into account the data-source.
+     */
+    getLayoutSupportedFeatures(): {
+        RowGroupedColumns: boolean;
+        AggregationColumns: boolean;
+        PivotColumns: boolean;
+        ColumnFilters: boolean;
+        ColumnSorts: boolean;
+    };
+    updateCurrentDraftLayout(layout: Layout): void;
+    hasLayoutSpecificObjects(): boolean;
+    isObjectAvailableInLayout(object: LayoutAssociatedObject, module: AdaptableModule, layout: Layout): boolean;
+    showLayoutNotAssociatedObjects(): boolean;
+}