@adaptabletools/adaptable 18.0.0-canary.9 → 18.0.0

package/src/Utilities/Services/ReportService.js

@@ -7,6 +7,8 @@ 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;
@@ -15,29 +17,12 @@ export class ReportService {
         this.excelStylesWithFormattedDate = {};
         this.adaptableApi = adaptableApi;
     }
-    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;
-    }
-    getRegisteredExcelStyles() {
-        return Object.values(this.excelStylesCache);
+    destroy() {
+        // TO DO
     }
     getExcelStyleIdForCellClassKey(cellClassKey) {
         return this.cellClassKey2excelStyleIdMap[cellClassKey];
     }
-    registerExcelStyleWithFormattedDate(cellClassId, isoFormattedValue) {
-        this.excelStylesWithFormattedDate[cellClassId] = isoFormattedValue;
-    }
     getExcelStyleWithFormattedDate(cellClassId) {
         return this.excelStylesWithFormattedDate[cellClassId];
     }
@@ -99,8 +84,11 @@ export class ReportService {
             reportName == VISUAL_DATA_REPORT);
     }
     IsSystemReportActive(reportName) {
-        if (reportName == SELECTED_CELLS_REPORT || reportName == SELECTED_ROWS_REPORT) {
-            return this.adaptableApi.gridApi.isGridSelectable();
+        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
@@ -146,7 +134,7 @@ export class ReportService {
             case 'SelectedColumns':
                 return '[Selected Columns]';
             case 'ScopeColumns':
-                return this.adaptableApi.scopeApi.getScopeDescription(report.Scope);
+                return this.adaptableApi.columnScopeApi.getScopeDescription(report.Scope);
         }
     }
     GetReportExpressionDescription(report, cols) {
@@ -209,7 +197,7 @@ export class ReportService {
                     reportColumns = report.Scope.ColumnIds.map((columnId) => this.adaptableApi.columnApi.getColumnWithColumnId(columnId)).filter((c) => c);
                 }
                 else {
-                    reportColumns = this.adaptableApi.scopeApi.getColumnsForScope(report.Scope);
+                    reportColumns = this.adaptableApi.columnScopeApi.getColumnsForScope(report.Scope);
                 }
                 break;
         }
@@ -365,9 +353,6 @@ export class ReportService {
         }
         return fileName;
     }
-    destroy() {
-        // TO DO
-    }
     getCustomExportDateFormat() {
         return this.adaptableApi.optionsApi.getExportOptions().exportDateFormat;
     }
@@ -379,4 +364,238 @@ export class ReportService {
             : // 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 isDateCellExportedAsFormattedValue = this.adaptableApi.exportApi.internalApi.isDateCellExportedAsFormattedValue();
+        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) => {
+            var _a;
+            const rowParams = {
+                node,
+                data: node.data,
+                rowIndex,
+                api: agGridApi,
+                columnApi: null,
+                context: ((_a = agGridApi.__getContext) === null || _a === void 0 ? void 0 : _a.call(agGridApi)) || {},
+            };
+            const getRowStyleFn = agGridApi.getGridOption('getRowStyle');
+            const rowStyle = getRowStyleFn ? getRowStyleFn(rowParams) : {};
+            displayedColumns.forEach((column, columnIndex) => {
+                var _a, _b, _c;
+                const colDef = colDefs[columnIndex];
+                let cellClassParams;
+                const getLazyCellClassParams = () => {
+                    if (!cellClassParams) {
+                        cellClassParams = {
+                            colDef,
+                            node,
+                            column,
+                            data: node.data,
+                            value: this.adaptableApi.gridApi.getRawValueFromRowNode(node, column.getId()),
+                            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/Services/RowSummaryService.d.ts

@@ -0,0 +1,26 @@
+import { AdaptableApi, Layout } from '../../types';
+import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
+/**
+ * The logic is extracted here to make it easier to follow
+ */
+export declare class RowSummaryService {
+    private api;
+    cachedCellSummary: Map<string, AggregatedScalarLiveValue>;
+    previousRowSummaries: any;
+    previousLayout: Layout | null;
+    constructor(api: AdaptableApi);
+    onAdapterReady(): void;
+    rowSummariesSubscriptions(): void;
+    _throttleAcumulatedColumnsThatChanged: Set<string>;
+    throttledEvaluateRowSummary(reason?: {
+        columnIds: string[];
+    }): void;
+    /**
+     *
+     * @param colId optional to evaluate only one column
+     */
+    _throttledEvaluateRowSummary: import("lodash").DebouncedFunc<(reason?: {
+        columnIds: string[];
+    }) => void>;
+    private evaluateRowSummary;
+}

package/src/Utilities/Services/RowSummaryService.js

@@ -0,0 +1,155 @@
+import { isEqual } from 'lodash';
+import { ROW_SUMMARY_ROW_ID, WEIGHTED_AVERAGE_AGGREATED_FUNCTION, } from '../../PredefinedConfig/Common/RowSummary';
+import { SystemRowSummarySet } from '../../Redux/ActionsReducers/SystemRedux';
+import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
+import Helper from '../Helpers/Helper';
+import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
+import { isObjectEmpty } from '../Extensions/ObjectExtensions';
+import throttle from 'lodash/throttle';
+/**
+ * The logic is extracted here to make it easier to follow
+ */
+export class RowSummaryService {
+    constructor(api) {
+        this.api = api;
+        this.cachedCellSummary = new Map();
+        this._throttleAcumulatedColumnsThatChanged = new Set();
+        /**
+         *
+         * @param colId optional to evaluate only one column
+         */
+        this._throttledEvaluateRowSummary = throttle(this.evaluateRowSummary, 300);
+    }
+    onAdapterReady() {
+        this.rowSummariesSubscriptions();
+    }
+    rowSummariesSubscriptions() {
+        // return;
+        if (this.api.isDestroyed()) {
+            return;
+        }
+        // Currently not available for serverside model
+        if (!this.api.layoutApi.internalApi.getLayoutSupportedFeatures().RowSummaries) {
+            return;
+        }
+        this.throttledEvaluateRowSummary();
+        this.api.eventApi.on('AdaptableStateReloaded', () => {
+            this.throttledEvaluateRowSummary();
+        });
+        this.api.eventApi.on('GridDataChanged', (event) => {
+            this.throttledEvaluateRowSummary();
+        });
+        this.api.eventApi.on('CellChanged', (event) => {
+            const columnId = event.cellChange.column.columnId;
+            this.throttledEvaluateRowSummary({
+                columnIds: [columnId],
+            });
+        });
+        this.api.eventApi.on('LayoutChanged', (event) => {
+            // exclude filter events, those are handled in another event
+            if (event.actionName.includes('FILTER')) {
+                return;
+            }
+            setTimeout(() => {
+                // the timeout is added so the grid has time to repond to the layout changed
+                this.throttledEvaluateRowSummary();
+            }, 16);
+        });
+        const adaptable = this.api.internalApi.getAdaptableInstance();
+        adaptable._on('AdapTableFiltersApplied', () => {
+            // we need to use this instead of layout changed
+            // so the rows have time to update
+            this.throttledEvaluateRowSummary();
+        });
+        adaptable._on('FirstDataRendered', () => {
+            this.throttledEvaluateRowSummary();
+        });
+    }
+    throttledEvaluateRowSummary(reason) {
+        if (reason) {
+            reason.columnIds.forEach((col) => this._throttleAcumulatedColumnsThatChanged.add(col));
+        }
+        this._throttledEvaluateRowSummary(reason);
+    }
+    evaluateRowSummary(reason) {
+        var _a;
+        if (this._throttleAcumulatedColumnsThatChanged.size > 0) {
+            const columnIds = Array.from(this._throttleAcumulatedColumnsThatChanged.values());
+            reason = {
+                columnIds,
+            };
+            this._throttleAcumulatedColumnsThatChanged.clear();
+        }
+        if (this.api.isDestroyed()) {
+            return;
+        }
+        const currentLayout = this.api.layoutApi.getCurrentLayout();
+        let previousLayout = this.previousLayout;
+        // it is added here to be sure it is saved
+        this.previousLayout = currentLayout;
+        /**
+         * If the previous & current layout does not have row summaries, it is safe to exit
+         */
+        if (isObjectEmpty(currentLayout === null || currentLayout === void 0 ? void 0 : currentLayout.RowSummaries) && isObjectEmpty(previousLayout === null || previousLayout === void 0 ? void 0 : previousLayout.RowSummaries)) {
+            return;
+        }
+        const rowSummaries = (_a = this.api.layoutApi.getCurrentLayout().RowSummaries) !== null && _a !== void 0 ? _a : [];
+        const rowSummariesResults = rowSummaries.map(({ ColumnsMap, Position }) => {
+            return {
+                Position,
+                RowData: Object.entries(ColumnsMap !== null && ColumnsMap !== void 0 ? ColumnsMap : {}).reduce((acc, [columnId, expression]) => {
+                    const key = `${columnId}-${expression}`;
+                    let expressionLiveValue = this.cachedCellSummary.get(key);
+                    if (expressionLiveValue) {
+                        if (!reason) {
+                            // refresh all of them
+                            expressionLiveValue.refresh();
+                        }
+                        else if ('columnIds' in reason && reason.columnIds.includes(columnId)) {
+                            expressionLiveValue.refresh();
+                        }
+                    }
+                    if (!expressionLiveValue) {
+                        try {
+                            let aggregatedScalarExpression = `${expression}([${columnId}])`;
+                            if (aggregatedScalarExpression.includes(WEIGHTED_AVERAGE_AGGREATED_FUNCTION) &&
+                                currentLayout.AggregationColumns[columnId] &&
+                                typeof currentLayout.AggregationColumns[columnId] === 'object') {
+                                const weight = currentLayout.AggregationColumns[columnId]
+                                    .weightedColumnId;
+                                if (weight) {
+                                    aggregatedScalarExpression = `AVG([${columnId}], WEIGHT([${weight}]))`;
+                                }
+                            }
+                            expressionLiveValue = new AggregatedScalarLiveValue({
+                                aggregatedScalarExpression,
+                            }, ModuleConstants.LayoutModuleId, this.api, () => {
+                                return this.api.gridApi.getVisibleRowNodes();
+                            });
+                        }
+                        catch (e) {
+                            this.api.logError('Error evaluating row summary', e);
+                        }
+                        this.cachedCellSummary.set(key, expressionLiveValue);
+                    }
+                    let value = null;
+                    if (expressionLiveValue) {
+                        value = expressionLiveValue.getGlobalAggregatedValue();
+                        if (typeof value === 'number' && !isNaN(value)) {
+                            value = Helper.roundNumber(value, 2);
+                        }
+                    }
+                    acc[columnId] = value;
+                    return acc;
+                }, {
+                    [ROW_SUMMARY_ROW_ID]: true,
+                }),
+            };
+        });
+        if (this.previousRowSummaries && isEqual(rowSummariesResults, this.previousRowSummaries)) {
+            return;
+        }
+        this.api.internalApi.dispatchReduxAction(SystemRowSummarySet(rowSummariesResults));
+        this.previousRowSummaries = rowSummariesResults;
+    }
+}

package/src/Utilities/Services/ValidationService.js

@@ -15,7 +15,7 @@ export class ValidationService {
         }
         let editingRules = this.adaptableApi.alertApi.internalApi
             .getAlertDefinitionsWithPreventEdit()
-            .filter((v) => this.adaptableApi.scopeApi.isColumnInScope(cellDataChangedInfo.column, v.Scope));
+            .filter((v) => this.adaptableApi.columnScopeApi.isColumnInScope(cellDataChangedInfo.column, v.Scope));
         let failedValidations = [];
         if (ArrayExtensions.IsNotEmpty(editingRules)) {
             editingRules.forEach((alertDefinition) => {
@@ -127,7 +127,7 @@ export class ValidationService {
     }
     createValidationDescription(alertDefinition) {
         var _a, _b;
-        return (this.adaptableApi.scopeApi.getScopeDescription(alertDefinition.Scope) +
+        return (this.adaptableApi.columnScopeApi.getScopeDescription(alertDefinition.Scope) +
             ' ' +
             ((_b = (_a = alertDefinition.Rule) === null || _a === void 0 ? void 0 : _a.Predicates) === null || _b === void 0 ? void 0 : _b.map((predicate) => this.adaptableApi.predicateApi.predicateToString(predicate)).join(' AND ')));
     }

package/src/Utilities/adaptableQlUtils.d.ts

@@ -0,0 +1,2 @@
+import { AdaptableColumnDataType, ExpressionFunctionInputType } from '../types';
+export declare const mapColumnDataTypeToExpressionFunctionType: (dataType: AdaptableColumnDataType) => ExpressionFunctionInputType;

package/src/Utilities/adaptableQlUtils.js

@@ -0,0 +1,14 @@
+export const mapColumnDataTypeToExpressionFunctionType = (dataType) => {
+    if (dataType === 'Number') {
+        return 'number';
+    }
+    if (dataType === 'Boolean') {
+        return 'boolean';
+    }
+    if (dataType === 'String') {
+        return 'text';
+    }
+    if (dataType === 'Date') {
+        return 'date';
+    }
+};

package/src/Utilities/license/decode.js

@@ -1,65 +1 @@
-import { compute_string } from './hashing';
-const getGenericError = () => new Error('Invalid License');
-export const GENERIC_APP_NAME = 'GenericAdaptableApp';
-export const fieldsToLicenseDetails = (fields) => {
-    var _a;
-    const fieldsMap = fields.reduce((acc, field) => {
-        acc.set(field.name, field.value);
-        return acc;
-    }, new Map());
-    const details = {
-        start: new Date(fieldsMap.get('StartDate')),
-        end: new Date(fieldsMap.get('EndDate')),
-        owner: fieldsMap.get('Owner'),
-        appName: fieldsMap.get('AppName') || GENERIC_APP_NAME,
-        timestamp: fieldsMap.get('TS') ? Number(fieldsMap.get('TS')) : 0,
-        trial: fieldsMap.get('Trial') === 'true' ? true : false,
-        ref: (_a = fieldsMap.get('Ref')) !== null && _a !== void 0 ? _a : '',
-    };
-    if (!details.start ||
-        !details.end ||
-        !details.owner ||
-        typeof details.trial !== 'boolean' ||
-        !details.ref) {
-        throw getGenericError();
-    }
-    return details;
-};
-export const decode = (licenseKey) => {
-    let crc = '';
-    let fields = licenseKey.split('|').map((part) => {
-        let [name, value] = part.split('=');
-        if (name === 'C') {
-            crc = value;
-        }
-        return {
-            name,
-            value,
-        };
-    });
-    if (!crc) {
-        throw getGenericError();
-    }
-    const crcParts = crc.split(',').reverse();
-    const overallCrc = crcParts.pop();
-    crcParts.forEach((fieldCrc, index) => {
-        const field = fields[index];
-        if (compute_string(field.value) !== fieldCrc) {
-            throw getGenericError();
-        }
-    });
-    const fieldsWithoutC = [...fields];
-    fieldsWithoutC.pop();
-    const fieldsWithoutCString = fieldsWithoutC
-        .map((field) => {
-        return `${field.name}=${field.value}`;
-    })
-        .join('|');
-    if (compute_string(fieldsWithoutCString) !== overallCrc) {
-        throw getGenericError();
-    }
-    fields = fields.map((f) => {
-        return Object.assign(Object.assign({}, f), { value: decodeURI(f.value) });
-    });
-    return fieldsToLicenseDetails(fields);
-};
+import{compute_string as e}from"./hashing";const t=()=>new Error("Invalid License");export const GENERIC_APP_NAME="GenericAdaptableApp";export const fieldsToLicenseDetails=e=>{var a;const r=e.reduce(((e,t)=>(e.set(t.name,t.value),e)),new Map),n={start:new Date(r.get("StartDate")),end:new Date(r.get("EndDate")),owner:r.get("Owner"),appName:r.get("AppName")||GENERIC_APP_NAME,timestamp:r.get("TS")?Number(r.get("TS")):0,trial:"true"===r.get("Trial"),ref:null!==(a=r.get("Ref"))&&void 0!==a?a:""};if(!(n.start&&n.end&&n.owner&&"boolean"==typeof n.trial&&n.ref))throw t();return n};export const decode=a=>{let r="",n=a.split("|").map((e=>{let[t,a]=e.split("=");return"C"===t&&(r=a),{name:t,value:a}}));if(!r)throw t();const o=r.split(",").reverse(),s=o.pop();o.forEach(((a,r)=>{const o=n[r];if(e(o.value)!==a)throw t()}));const i=[...n];i.pop();const p=i.map((e=>`${e.name}=${e.value}`)).join("|");if(e(p)!==s)throw t();return n=n.map((e=>Object.assign(Object.assign({},e),{value:decodeURI(e.value)}))),fieldsToLicenseDetails(n)};

package/src/Utilities/license/hashing.js

@@ -1,43 +1 @@
-const DEFAULT_ReversedPolynomial = 0xedb88320;
-/*
- * CRC-32 implementation
- */
-function generate(reversedPolynomial = DEFAULT_ReversedPolynomial) {
-    var table = new Array();
-    var i, j, n;
-    for (i = 0; i < 256; i++) {
-        n = i;
-        for (j = 8; j > 0; j--) {
-            if ((n & 1) == 1) {
-                n = (n >>> 1) ^ reversedPolynomial;
-            }
-            else {
-                n = n >>> 1;
-            }
-        }
-        table[i] = n;
-    }
-    return table;
-}
-function crc32_initial() {
-    return 0xffffffff;
-}
-function crc32_add_byte(table, crc, byte) {
-    crc = (crc >>> 8) ^ table[byte ^ (crc & 0x000000ff)];
-    return crc;
-}
-function crc32_final(crc) {
-    crc = ~crc;
-    crc = crc < 0 ? 0xffffffff + crc + 1 : crc;
-    return crc;
-}
-export function compute_string(str, reversedPolynomial = DEFAULT_ReversedPolynomial) {
-    var table = generate(reversedPolynomial);
-    var crc = 0;
-    var i;
-    crc = crc32_initial();
-    for (i = 0; i < str.length; i++)
-        crc = crc32_add_byte(table, crc, str.charCodeAt(i));
-    crc = crc32_final(crc);
-    return `${crc}`;
-}
+const r=3988292384;function n(n=r){var t,o,u,e=new Array;for(t=0;t<256;t++){for(u=t,o=8;o>0;o--)1&~u?u>>>=1:u=u>>>1^n;e[t]=u}return e}function t(){return 4294967295}function o(r,n,t){return n=n>>>8^r[t^255&n]}function u(r){return r=(r=~r)<0?4294967295+r+1:r}export function compute_string(e,c=r){var f,i=n(c),a=0;for(a=t(),f=0;f<e.length;f++)a=o(i,a,e.charCodeAt(f));return`${a=u(a)}`}

package/src/View/AdaptableViewFactory.js

@@ -29,7 +29,7 @@ import { StatusBarPopup } from './StatusBar/StatusBarPopup';
 import { ChartingViewPanel } from './Charting/ChartingViewPanel';
 import { GridFilterPopup } from './GridFilter/GridFilterPopup';
 import { ColumnInfoPopup } from './ColumnInfo/ColumnInfoPopup';
-import { NotesPopup } from './Notes/NotesPopup';
+import { NotePopup } from './Note/NotePopup';
 import { CommentsPopup } from './Comments/CommentsPopup';
 import { DataImportPopup } from './DataImport/DataImportPopup';
 export const AdaptableViewFactory = {
@@ -46,7 +46,7 @@ export const AdaptableViewFactory = {
     ToolPanelPopup,
     SystemStatusPopup,
     DataChangeHistoryPopup,
-    NotesPopup,
+    NotePopup,
     CommentsPopup,
     DataImportPopup,
     GridFilterPopup,