@adaptabletools/adaptable 18.1.14 → 19.0.0-canary.0

package/src/Utilities/Services/ReportService.js

@@ -1,603 +0,0 @@
-import groupBy from 'lodash/groupBy';
-import { ExportDestination } from '../../PredefinedConfig/Common/Enums';
-import { ALL_DATA_REPORT, CURRENT_DATA_REPORT, SELECTED_CELLS_REPORT, SELECTED_ROWS_REPORT, VISUAL_DATA_REPORT, } from '../Constants/GeneralConstants';
-import ArrayExtensions from '../Extensions/ArrayExtensions';
-import FormatHelper, { DateFormatter } from '../Helpers/FormatHelper';
-import StringExtensions from '../Extensions/StringExtensions';
-import { ExportModuleId } from '../Constants/ModuleConstants';
-import { createUuid } from '../../components/utils/uuid';
-import { createBaseContext } from '../ObjectFactory';
-import { convertCSSAbsoluteFontSizeToPt, getVariableColor, sanitizeStyle, } from '../Helpers/StyleHelper';
-import tinycolor from 'tinycolor2';
-export class ReportService {
-    constructor(adaptableApi) {
-        this.adaptableApi = adaptableApi;
-        this.excelStylesCache = {};
-        this.cellClassKey2excelStyleIdMap = {};
-        this.excelStylesWithFormattedDate = {};
-        this.adaptableApi = adaptableApi;
-    }
-    destroy() {
-        // TO DO
-    }
-    getExcelStyleIdForCellClassKey(cellClassKey) {
-        return this.cellClassKey2excelStyleIdMap[cellClassKey];
-    }
-    getExcelStyleWithFormattedDate(cellClassId) {
-        return this.excelStylesWithFormattedDate[cellClassId];
-    }
-    CreateSystemReport(systemReportName) {
-        switch (systemReportName) {
-            case VISUAL_DATA_REPORT:
-                return {
-                    Uuid: createUuid(),
-                    Name: VISUAL_DATA_REPORT,
-                    ReportColumnScope: 'VisibleColumns',
-                    ReportRowScope: 'VisibleRows',
-                    Query: undefined,
-                    IsReadOnly: true,
-                };
-            case ALL_DATA_REPORT:
-                return {
-                    Uuid: createUuid(),
-                    Name: ALL_DATA_REPORT,
-                    ReportColumnScope: 'AllColumns',
-                    ReportRowScope: 'AllRows',
-                    Query: undefined,
-                    IsReadOnly: true,
-                };
-            case CURRENT_DATA_REPORT:
-                return {
-                    Uuid: createUuid(),
-                    Name: CURRENT_DATA_REPORT,
-                    ReportColumnScope: 'VisibleColumns',
-                    ReportRowScope: 'VisibleRows',
-                    Query: undefined,
-                    IsReadOnly: true,
-                };
-            case SELECTED_CELLS_REPORT:
-                return {
-                    Uuid: createUuid(),
-                    Name: SELECTED_CELLS_REPORT,
-                    ReportColumnScope: 'SelectedColumns',
-                    ReportRowScope: 'SelectedCellRows',
-                    Query: undefined,
-                    IsReadOnly: true,
-                };
-            case SELECTED_ROWS_REPORT:
-                return {
-                    Uuid: createUuid(),
-                    Name: SELECTED_ROWS_REPORT,
-                    ReportColumnScope: 'VisibleColumns',
-                    ReportRowScope: 'SelectedRows',
-                    Query: undefined,
-                    IsReadOnly: true,
-                };
-        }
-    }
-    IsSystemReport(reportName) {
-        return (reportName == null ||
-            reportName == ALL_DATA_REPORT ||
-            reportName == CURRENT_DATA_REPORT ||
-            reportName == SELECTED_CELLS_REPORT ||
-            reportName == SELECTED_ROWS_REPORT ||
-            reportName == VISUAL_DATA_REPORT);
-    }
-    IsSystemReportActive(reportName) {
-        if (reportName == SELECTED_CELLS_REPORT) {
-            return this.adaptableApi.gridApi.isGridRangeSelectable();
-        }
-        if (reportName == SELECTED_ROWS_REPORT) {
-            return this.adaptableApi.gridApi.isGridRowSelectable();
-        }
-        if (reportName === VISUAL_DATA_REPORT) {
-            return this.adaptableApi.exportApi
-                .getAvailableExportDestinations()
-                .includes(ExportDestination.Excel);
-        }
-        return true;
-    }
-    IsSystemExportDestinationActive(exportDestination) {
-        if (exportDestination === ExportDestination.Excel) {
-            return this.adaptableApi.exportApi.canExportToExcel();
-        }
-        return true;
-    }
-    GetReportColumnScopeShortDescription(report) {
-        var _a, _b;
-        if (this.adaptableApi.exportApi.isExternalReport(report)) {
-            return ['[Custom Columns]'];
-        }
-        switch (report.ReportColumnScope) {
-            case 'AllColumns':
-                return ['[All Columns]'];
-            case 'VisibleColumns':
-                return ['[Visible Columns]'];
-            case 'SelectedColumns':
-                return ['[Selected Columns]'];
-            case 'ScopeColumns':
-                if ('ColumnIds' in (report === null || report === void 0 ? void 0 : report.Scope)) {
-                    return (_b = (_a = report.Scope.ColumnIds).map) === null || _b === void 0 ? void 0 : _b.call(_a, (columnId) => { var _a; return (_a = this.adaptableApi.columnApi.getFriendlyNameForColumnId(columnId)) !== null && _a !== void 0 ? _a : columnId; });
-                }
-                return ['[Bespoke Columns]'];
-        }
-    }
-    GetReportColumnScopeLongDescription(report) {
-        if (this.adaptableApi.exportApi.isExternalReport(report)) {
-            return '[Custom Columns]';
-        }
-        switch (report.ReportColumnScope) {
-            case 'AllColumns':
-                return '[All Columns]';
-            case 'VisibleColumns':
-                return '[Visible Columns]';
-            case 'SelectedColumns':
-                return '[Selected Columns]';
-            case 'ScopeColumns':
-                return this.adaptableApi.columnScopeApi.getScopeDescription(report.Scope);
-        }
-    }
-    GetReportExpressionDescription(report, cols) {
-        if (this.adaptableApi.exportApi.isExternalReport(report)) {
-            return '[Custom Data]';
-        }
-        if (this.IsSystemReport(report.Name)) {
-            if (report.Name == ALL_DATA_REPORT) {
-                return '[All Data]';
-            }
-            else if (report.Name == CURRENT_DATA_REPORT) {
-                return '[All Current Data]';
-            }
-            else if (report.Name == SELECTED_CELLS_REPORT) {
-                return '[Selected Cells Data]';
-            }
-            else if (report.Name == SELECTED_ROWS_REPORT) {
-                return '[Selected Rows Data]';
-            }
-            else if (report.Name == VISUAL_DATA_REPORT) {
-                return '[Current Data as WYSIWYG]';
-            }
-        }
-        else {
-            switch (report.ReportRowScope) {
-                case 'AllRows':
-                    return '[All Rows]';
-                case 'VisibleRows':
-                    return '[Visible Rows]';
-                case 'SelectedRows':
-                    return '[Selected Rows]';
-                case 'ExpressionRows':
-                    return this.adaptableApi.internalApi.getAdaptableQueryExpressionText(report.Query);
-            }
-        }
-    }
-    getReportDataColumns(report, includePrimaryKey = false) {
-        let reportColumns = [];
-        let gridColumns = this.adaptableApi.columnApi.getExportableColumns();
-        if (this.adaptableApi.exportApi.isExternalReport(report)) {
-            return reportColumns;
-        }
-        // first get the cols depending on the Column Scope
-        switch (report.ReportColumnScope) {
-            case 'AllColumns':
-                reportColumns = gridColumns;
-                break;
-            case 'VisibleColumns':
-                reportColumns = gridColumns.filter((c) => c.visible);
-                break;
-            case 'SelectedColumns':
-                // we extract the selected columns from the grid columns to preserve the grid column order
-                const selectedColumnIds = this.adaptableApi.gridApi
-                    .getSelectedCellInfo()
-                    .columns.map((column) => column.columnId);
-                reportColumns = gridColumns.filter((gridColumn) => selectedColumnIds.includes(gridColumn.columnId));
-                break;
-            case 'ScopeColumns':
-                if ('ColumnIds' in report.Scope) {
-                    reportColumns = report.Scope.ColumnIds.map((columnId) => this.adaptableApi.columnApi.getColumnWithColumnId(columnId)).filter((c) => c);
-                }
-                else {
-                    reportColumns = this.adaptableApi.columnScopeApi.getColumnsForScope(report.Scope);
-                }
-                break;
-        }
-        if (includePrimaryKey) {
-            const pkColumn = reportColumns.find((column) => column.columnId === this.adaptableApi.optionsApi.getPrimaryKey());
-            // TODO simplify after we fix the IsPrimaryKey bug
-            // const pkColumn = reportColumns.find(column => column.IsPrimaryKey);
-            if (!pkColumn && !!this.adaptableApi.columnApi.getPrimaryKeyColumn()) {
-                reportColumns.push(this.adaptableApi.columnApi.getPrimaryKeyColumn());
-            }
-        }
-        return reportColumns.map((column) => {
-            var _a;
-            return ({
-                columnId: column.columnId,
-                friendlyName: column.friendlyName,
-                dataType: column.dataType,
-                field: (_a = column.field) !== null && _a !== void 0 ? _a : column.columnId,
-            });
-        });
-    }
-    getReportDataRows(report, columns, includePrimaryKey) {
-        var _a, _b;
-        if (ArrayExtensions.IsNullOrEmpty(columns)) {
-            return [];
-        }
-        const columnIds = columns.map((column) => column.columnId);
-        const resultRowData = [];
-        switch (report.ReportRowScope) {
-            case 'AllRows':
-                this.adaptableApi.internalApi.forAllRowNodesDo((rowNode) => {
-                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
-                });
-                break;
-            case 'VisibleRows':
-                this.adaptableApi.internalApi.forAllVisibleRowNodesDo((rowNode) => {
-                    resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
-                });
-                break;
-            case 'ExpressionRows':
-                this.adaptableApi.internalApi.forAllRowNodesDo((rowNode) => {
-                    var _a;
-                    if (this.adaptableApi.internalApi
-                        .getQueryLanguageService()
-                        .evaluateBooleanExpression((_a = report.Query) === null || _a === void 0 ? void 0 : _a.BooleanExpression, ExportModuleId, rowNode)) {
-                        resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
-                    }
-                });
-                break;
-            case 'SelectedCellRows':
-                const selectedCellInfo = this.adaptableApi.gridApi.getSelectedCellInfo();
-                const { gridCells: GridCells } = selectedCellInfo;
-                let selectedCellsByPrimaryKey = groupBy(GridCells, 'primaryKeyValue');
-                // we iterate over all visibleRowNodes to preserve the current order
-                this.adaptableApi.internalApi.forAllVisibleRowNodesDo((rowNode) => {
-                    const rowPrimaryKeyValue = this.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(rowNode);
-                    const selectedRowCells = selectedCellsByPrimaryKey[rowPrimaryKeyValue];
-                    if (selectedRowCells) {
-                        const selectedRowColumnIds = selectedRowCells.map((rowCell) => rowCell.column.columnId);
-                        const selectedColumnIds = columnIds.filter((columnId) => selectedRowColumnIds.includes(columnId));
-                        const row = this.getRowObjectForColumnIds(rowNode, selectedColumnIds);
-                        if (includePrimaryKey) {
-                            row[this.adaptableApi.optionsApi.getPrimaryKey()] = rowPrimaryKeyValue;
-                        }
-                        resultRowData.push(row);
-                    }
-                });
-                break;
-            case 'SelectedRows':
-                const selectedRowInfo = this.adaptableApi.gridApi.getSelectedRowInfo();
-                const selectedGridRowPrimaryKeys = (_b = (_a = selectedRowInfo === null || selectedRowInfo === void 0 ? void 0 : selectedRowInfo.gridRows) === null || _a === void 0 ? void 0 : _a.filter((gr) => gr.rowInfo.isGroup == false).map((gridRow) => gridRow.primaryKeyValue)) !== null && _b !== void 0 ? _b : [];
-                if (selectedGridRowPrimaryKeys.length) {
-                    this.adaptableApi.internalApi.forAllRowNodesDo((rowNode) => {
-                        const rowPrimaryKeyValue = this.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(rowNode);
-                        if (selectedGridRowPrimaryKeys.includes(rowPrimaryKeyValue)) {
-                            resultRowData.push(this.getRowObjectForColumnIds(rowNode, columnIds));
-                        }
-                    });
-                }
-                break;
-        }
-        return resultRowData;
-    }
-    getReportData(report, includePrimaryKey = false) {
-        if (this.adaptableApi.exportApi.isExternalReport(report)) {
-            return this.adaptableApi.exportApi.runExternalReport(report.Name);
-        }
-        const columns = this.getReportDataColumns(report, includePrimaryKey);
-        const rows = this.getReportDataRows(report, columns, includePrimaryKey);
-        return { columns, rows };
-    }
-    getReportDataAsArray(report, includePrimaryKey = false) {
-        const reportData = this.getReportData(report, includePrimaryKey);
-        return this.convertReportDataToArray(reportData);
-    }
-    convertReportDataToArray(reportData) {
-        return [
-            reportData.columns.map((column) => column.friendlyName),
-            ...reportData.rows.map((row) => reportData.columns.map((column) => row[column.columnId])),
-        ];
-    }
-    getRowObjectForColumnIds(rowNode, columnIds) {
-        return columnIds.reduce((result, columnId) => {
-            result[columnId] = this.getCellExportValueFromRowNode(rowNode, columnId);
-            return result;
-        }, {});
-    }
-    PublishLiveLiveDataChangedEvent(reportDestination, liveDataTrigger, liveReport) {
-        const liveDataChangedInfo = {
-            adaptableApi: this.adaptableApi,
-            reportDestination: reportDestination,
-            liveDataTrigger: liveDataTrigger,
-            liveReport: liveReport,
-            userName: this.adaptableApi.optionsApi.getUserName(),
-            adaptableId: this.adaptableApi.optionsApi.getAdaptableId(),
-        };
-        this.adaptableApi.eventApi.emit('LiveDataChanged', liveDataChangedInfo);
-    }
-    getCellExportValueFromRowNode(rowNode, columnId) {
-        return this.getCellExportValueFromRawValue(rowNode, this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, columnId), columnId);
-    }
-    getCellExportValueFromRawValue(rowNode, cellRawValue, columnId) {
-        if (StringExtensions.IsNullOrEmpty(cellRawValue)) {
-            return cellRawValue;
-        }
-        const column = this.adaptableApi.columnApi.getColumnWithColumnId(columnId);
-        const columnDataType = column.dataType;
-        // if this is a date column and there is a custom export date format provided, that will take precedence
-        if (columnDataType === 'Date' && !!this.getCustomExportDateFormat()) {
-            const exportDateFormat = this.getCustomExportDateFormat();
-            return FormatHelper.DateFormatter(cellRawValue, {
-                Pattern: exportDateFormat,
-            });
-        }
-        // otherwise check the general export format types
-        let cellExportFormat = this.adaptableApi.exportApi.internalApi.getCellExportFormatType(column, columnDataType);
-        return this.getCellExportValueFromRawValueByType(rowNode, cellRawValue, columnId, cellExportFormat);
-    }
-    getReportFileName(reportName, destination) {
-        let fileName;
-        const reportFilename = this.adaptableApi.optionsApi.getExportOptions().reportFilename;
-        if (reportFilename) {
-            const reportFileNameContext = Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { reportName,
-                destination });
-            fileName = reportFilename(reportFileNameContext);
-        }
-        else {
-            fileName = StringExtensions.ReplaceEmptySpacesWithUnderscore(reportName);
-            if (this.adaptableApi.optionsApi.getExportOptions().appendFileTimestamp) {
-                fileName = `${fileName}_${DateFormatter(new Date(), {
-                    Pattern: 'yyyyMMdd_HHmmss',
-                })}`;
-            }
-        }
-        return fileName;
-    }
-    getCustomExportDateFormat() {
-        return this.adaptableApi.optionsApi.getExportOptions().exportDateFormat;
-    }
-    getCellExportValueFromRawValueByType(rowNode, cellRawValue, columnId, 
-    // default to rawValue if, for some reason, the configs provide invalid values
-    type = 'rawValue') {
-        return type === 'rawValue'
-            ? cellRawValue
-            : // type === formattedValue
-                this.adaptableApi.gridApi.getDisplayValueFromRawValue(rowNode, columnId, cellRawValue);
-    }
-    // aggregate and merge all acive Adaptable styles with the user proviided ExcelStyles
-    buildExcelStylesForVisualReports() {
-        // for historical reasons, the styles are merged as class variables
-        // we could/should refactor this to be more functional
-        this.createExcelStyleMemoization();
-        return Object.values(this.excelStylesCache);
-    }
-    createExcelStyleMemoization() {
-        this.resetExcelStyleMemoization();
-        // we memoize as much as possible, as this is called quite A LOT
-        const adaptableColumnMap = {};
-        const getAdaptableColumnWithColumnId = (columnId) => {
-            const memoizedColumn = adaptableColumnMap[columnId];
-            if (memoizedColumn) {
-                return memoizedColumn;
-            }
-            const abColumn = this.adaptableApi.columnApi.getColumnWithColumnId(columnId);
-            adaptableColumnMap[columnId] = abColumn;
-            return abColumn;
-        };
-        const formatColumnsWithDisplayFormatForColumn = {};
-        const getFormatColumnsWithDisplayFormatForColumn = (columnId) => {
-            const memoizedFormatColumns = formatColumnsWithDisplayFormatForColumn[columnId];
-            if (memoizedFormatColumns) {
-                return memoizedFormatColumns;
-            }
-            const abColumn = getAdaptableColumnWithColumnId(columnId);
-            const formatColumns = this.adaptableApi.formatColumnApi.internalApi.getFormatColumnsWithDisplayFormatForColumn(abColumn);
-            formatColumnsWithDisplayFormatForColumn[columnId] = formatColumns;
-            return formatColumns;
-        };
-        const displayedColumns = this.adaptableApi.agGridApi.getAllDisplayedColumns();
-        const colDefs = displayedColumns.map((column) => {
-            return column.getColDef();
-        });
-        const forAllVisibleRowNodesDoConfig = { includeGroupRows: true };
-        const agGridApi = this.adaptableApi.agGridApi;
-        const userExcelStyles = this.adaptableApi.internalApi
-            .getAdaptableInstance()
-            .agGridAdapter.getUserGridOptionsProperty('excelStyles') || [];
-        this.adaptableApi.internalApi.forAllVisibleRowNodesDo((node, rowIndex) => {
-            const rowParams = {
-                node,
-                data: node.data,
-                rowIndex,
-                api: agGridApi,
-                columnApi: null,
-                context: agGridApi.getGridOption('context') || {},
-            };
-            const getRowStyleFn = agGridApi.getGridOption('getRowStyle');
-            const rowStyle = getRowStyleFn ? getRowStyleFn(rowParams) : {};
-            displayedColumns.forEach((column, columnIndex) => {
-                var _a, _b, _c;
-                const colDef = colDefs[columnIndex];
-                const columnId = column.getId();
-                const adaptableColumn = this.adaptableApi.columnApi.getColumnWithColumnId(columnId);
-                const isDateCellExportedAsFormattedValue = this.adaptableApi.exportApi.internalApi.isDateCellExportedAsFormattedValue(adaptableColumn);
-                let cellClassParams;
-                const getLazyCellClassParams = () => {
-                    if (!cellClassParams) {
-                        cellClassParams = {
-                            colDef,
-                            node,
-                            column,
-                            data: node.data,
-                            value: this.adaptableApi.gridApi.getRawValueFromRowNode(node, columnId),
-                            rowIndex,
-                            api: agGridApi,
-                            columnApi: null,
-                            context: {},
-                        };
-                    }
-                    return cellClassParams;
-                };
-                const cellStyle = typeof colDef.cellStyle === 'function' ? colDef.cellStyle(getLazyCellClassParams()) : {};
-                const excelStyles = [];
-                // add user defined excel styles
-                let userColDefCellClass = this.adaptableApi.internalApi
-                    .getAdaptableInstance()
-                    .agGridColumnAdapter.getUserColDefProperty(column.getColId(), 'cellClass');
-                const userDefinedCellClass = typeof userColDefCellClass === 'function'
-                    ? userColDefCellClass(getLazyCellClassParams())
-                    : userColDefCellClass;
-                const userDefinedExcelStyle = userDefinedCellClass &&
-                    userExcelStyles.find((excelStyle) => {
-                        var _a;
-                        return typeof userDefinedCellClass === 'string'
-                            ? userDefinedCellClass === excelStyle.id
-                            : (_a = userDefinedCellClass === null || userDefinedCellClass === void 0 ? void 0 : userDefinedCellClass.includes) === null || _a === void 0 ? void 0 : _a.call(userDefinedCellClass, excelStyle.id);
-                    });
-                if (userDefinedExcelStyle) {
-                    excelStyles.push(userDefinedExcelStyle);
-                }
-                // add adaptable derived styles (format column etc.)
-                const adaptableStyle = Object.assign(Object.assign({}, rowStyle), Object.keys(cellStyle).reduce((result, key) => {
-                    if (cellStyle[key] !== null) {
-                        result[key] = cellStyle[key];
-                    }
-                    return result;
-                }, {}));
-                const sanitizedAdaptableStyle = sanitizeStyle(adaptableStyle);
-                if (Object.values(sanitizedAdaptableStyle).some((style) => style != null)) {
-                    excelStyles.push(this.convertCSSToExcelStyle(sanitizedAdaptableStyle));
-                }
-                const excelDataType = this.adaptableApi.exportApi.internalApi.getExcelDataType(colDef === null || colDef === void 0 ? void 0 : colDef.type);
-                const rawValue = this.adaptableApi.gridApi.getRawValueFromRowNode(node, column.getId());
-                // don't add the cell style if it has no adaptable custom styles
-                if (!excelStyles.length &&
-                    // if this is a formatted Date value, we still need to add the AG GRID specific type & numberFormat below
-                    !(excelDataType === 'DateTime' && isDateCellExportedAsFormattedValue)) {
-                    return;
-                }
-                const cellClassId = this.adaptableApi.internalApi
-                    .getAdaptableInstance()
-                    .agGridColumnAdapter.getExcelClassNameForCell(column.getId(), this.adaptableApi.internalApi
-                    .getAdaptableInstance()
-                    .getPrimaryKeyValueFromRowNode(node), userDefinedCellClass);
-                const finalCellExcelStyle = Object.assign({}, ...excelStyles);
-                if (excelDataType === 'DateTime' && isDateCellExportedAsFormattedValue) {
-                    let dateFormatPattern = this.adaptableApi.optionsApi.getExportOptions().exportDateFormat;
-                    const abColumn = getAdaptableColumnWithColumnId(column.getColId());
-                    if (!dateFormatPattern) {
-                        const mostRelevantFormatColumn = this.adaptableApi.formatColumnApi.internalApi.getMostRelevantFormatColumnForColumn(getFormatColumnsWithDisplayFormatForColumn(column.getColId()), abColumn, { node, value: rawValue });
-                        dateFormatPattern =
-                            ((_a = mostRelevantFormatColumn === null || mostRelevantFormatColumn === void 0 ? void 0 : mostRelevantFormatColumn.DisplayFormat) === null || _a === void 0 ? void 0 : _a.Formatter) === 'DateFormatter' &&
-                                ((_c = (_b = mostRelevantFormatColumn === null || mostRelevantFormatColumn === void 0 ? void 0 : mostRelevantFormatColumn.DisplayFormat) === null || _b === void 0 ? void 0 : _b.Options) === null || _c === void 0 ? void 0 : _c.Pattern);
-                    }
-                    if (dateFormatPattern) {
-                        const normalisedValue = this.adaptableApi.internalApi
-                            .getAdaptableInstance()
-                            .getNormalisedValueFromRawValue(rawValue, abColumn);
-                        if (normalisedValue) {
-                            // we have to pass the date in the ISO format to Excel
-                            // see https://www.ag-grid.com/javascript-data-grid/excel-export-data-types/#dates
-                            // we can NOT use Date.toISOString() because we don't want the timezone corrections to kick in
-                            const isoFormattedValue = DateFormatter(normalisedValue, {
-                                Pattern: `yyyy-MM-dd'T'HH:mm:ss.SSS`,
-                            });
-                            if (isoFormattedValue) {
-                                finalCellExcelStyle.dataType = 'DateTime';
-                                finalCellExcelStyle.numberFormat = { format: dateFormatPattern };
-                                // create a new cell key to ensure any user provided className does not interfere
-                                const cellKey = this.adaptableApi.internalApi
-                                    .getAdaptableInstance()
-                                    .agGridColumnAdapter.getExcelClassNameForCell(column.getColId(), this.adaptableApi.internalApi
-                                    .getAdaptableInstance()
-                                    .getPrimaryKeyValueFromRowNode(node));
-                                // we need to register so that later the cellProcessor will put the isoFormattedValue through (thus giving the formatting responsability to Excel)
-                                this.registerExcelStyleWithFormattedDate(cellKey, isoFormattedValue);
-                            }
-                        }
-                    }
-                }
-                this.registerExcelStyle(finalCellExcelStyle, cellClassId);
-            });
-        }, forAllVisibleRowNodesDoConfig);
-    }
-    convertCSSToExcelStyle(style) {
-        const getHexColor = (color) => {
-            const preparedColor = getVariableColor(color);
-            const t = tinycolor(preparedColor);
-            const a = t.getAlpha();
-            return tinycolor.mix(tinycolor('white'), t, a * 100).toHexString();
-        };
-        let result = {};
-        if (style.backgroundColor != null) {
-            result.interior = {
-                color: getHexColor(style.backgroundColor),
-                pattern: 'Solid',
-            };
-        }
-        if (style.borderColor != null) {
-            const excelBorder = {
-                color: style.borderColor,
-                lineStyle: 'Continuous',
-                weight: 1,
-            };
-            result.borders = {
-                borderBottom: excelBorder,
-                borderLeft: excelBorder,
-                borderRight: excelBorder,
-                borderTop: excelBorder,
-            };
-        }
-        if (style.textAlign) {
-            result.alignment = {
-                horizontal: StringExtensions.CapitaliseFirstLetter(style.textAlign),
-            };
-        }
-        if (style.color != null) {
-            if (!result.font) {
-                result.font = {};
-            }
-            result.font = {
-                color: getHexColor(style.color),
-            };
-        }
-        if (style.fontStyle === 'italic') {
-            if (!result.font) {
-                result.font = {};
-            }
-            result.font.italic = true;
-        }
-        if (style.fontWeight != null &&
-            (style.fontWeight === 'bold' || Number(style.fontWeight) >= 600)) {
-            if (!result.font) {
-                result.font = {};
-            }
-            result.font.bold = true;
-        }
-        if (style.fontSize != null) {
-            if (!result.font) {
-                result.font = {};
-            }
-            result.font.size = convertCSSAbsoluteFontSizeToPt(style.fontSize);
-        }
-        return result;
-    }
-    resetExcelStyleMemoization() {
-        this.excelStylesCache = {};
-        this.cellClassKey2excelStyleIdMap = {};
-        this.excelStylesWithFormattedDate = {};
-    }
-    registerExcelStyle(excelStyle, cellClassKey) {
-        const excelStyleKey = JSON.stringify(excelStyle);
-        if (!this.excelStylesCache[excelStyleKey]) {
-            const excelStyleId = createUuid();
-            const excelStyleWithId = Object.assign(Object.assign({}, excelStyle), { id: excelStyleId });
-            this.excelStylesCache[excelStyleKey] = excelStyleWithId;
-        }
-        this.cellClassKey2excelStyleIdMap[cellClassKey] = this.excelStylesCache[excelStyleKey].id;
-    }
-    registerExcelStyleWithFormattedDate(cellClassId, isoFormattedValue) {
-        this.excelStylesWithFormattedDate[cellClassId] = isoFormattedValue;
-    }
-}

package/src/Utilities/isAdaptableObject.d.ts

@@ -1,2 +0,0 @@
-import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
-export declare const isAdaptableObject: (object: unknown) => object is AdaptableObject;

package/src/Utilities/isAdaptableObject.js

@@ -1,4 +0,0 @@
-// pretty primitive type guard for AdaptableObject, but currently there is no better/safer way
-export const isAdaptableObject = (object) => {
-    return object != undefined && typeof object['Uuid'] === 'string';
-};

package/src/Utilities/reorder.d.ts

@@ -1 +0,0 @@
-export declare const reorder: (list: any[], startIndex: number, endIndex: number) => any[];

package/src/Utilities/reorder.js

@@ -1,13 +0,0 @@
-export const reorder = (list, startIndex, endIndex) => {
-    const result = [...list];
-    if (startIndex > list.length - 1) {
-        // not much that we can do if the dragged item is out of bounds...
-        return result;
-    }
-    if (endIndex > list.length - 1) {
-        endIndex = list.length - 1;
-    }
-    const [removed] = result.splice(startIndex, 1);
-    result.splice(endIndex, 0, removed);
-    return result;
-};

package/src/Utilities/sortWithOrder.d.ts

@@ -1,11 +0,0 @@
-export declare function sortWithOrderArray<T>(arr: T[], order: T[], 
-/**
- *
- * The array can contain items which are not listed in the order array.
- * So sortUnorderedItems decides whether to leave these items untouched
- * in the current order in which they are in the array (sortUnorderedItems: false)
- * or to sort them using normal comparison rules
- */
-{ sortUnorderedItems: sortUnorderedItems }: {
-    sortUnorderedItems: boolean;
-}): T[];