@adaptabletools/adaptable 14.0.0-canary.0 → 14.0.0-canary.2

package/src/Utilities/Services/ModuleService.js

@@ -87,8 +87,6 @@ class ModuleService {
                 return learnUrl + 'handbook-calculated-column';
             case 'CellSummary':
                 return learnUrl + 'handbook-summarising#cell-summary-information';
-            case 'ConditionalStyle':
-                return learnUrl + 'handbook-conditional-styling';
             case 'CustomSort':
                 return learnUrl + 'handbook-sorting';
             case 'Dashboard':
@@ -141,6 +139,10 @@ class ModuleService {
                 return learnUrl + 'integrations-ipushpull';
             case 'OpenFin':
                 return learnUrl + 'integrations-openfin';
+            case 'StyledColumn':
+                return learnUrl + 'handbook-styled-column-overview';
+            case 'Charting':
+                return learnUrl + 'handbook-charts';
             default:
                 return 'good';
         }

package/src/Utilities/Services/QueryLanguageService.d.ts

@@ -1,9 +1,8 @@
-import { IQueryLanguageService } from './Interface/IQueryLanguageService';
+import { IQueryLanguageService, ModuleExpressionFunctionsMap } from './Interface/IQueryLanguageService';
 import { Observable } from 'rxjs';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { RowNode } from '@ag-grid-community/core';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
-import { ModuleExpressionFunctions } from '../../AdaptableOptions/AdaptableQLOptions';
 import { ScalarAggregationParameter } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
 import { AdaptableApi } from '../../../types';
 import { BooleanAggregationParameter } from '../ExpressionFunctions/aggregatedBooleanExpressionFunctions';
@@ -43,7 +42,8 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     getNamedQueryNamesFromExpression(input?: string): string[];
     isCumulativeAggregate(input: string): boolean;
     getExpressionWithColumnFriendlyNames(expression?: string): string;
-    getModuleExpressionFunctions(module: AdaptableModule): ModuleExpressionFunctions;
+    getModuleExpressionFunctionsMap(module: AdaptableModule): ModuleExpressionFunctionsMap;
+    private extractMappedExpressionFunctions;
     evaluateCustomQueryVariable(functionName: string, args?: any[]): any;
     private getBooleanAndScalarFunctions;
     private getExpressionCacheKey;

package/src/Utilities/Services/QueryLanguageService.js

@@ -5,7 +5,13 @@ const tslib_1 = require("tslib");
 const parser = tslib_1.__importStar(require("../../parser/src"));
 const rxjs_1 = require("rxjs");
 const LoggingHelper_1 = require("../Helpers/LoggingHelper");
+const aggregatedScalarExpressionFunctions_1 = require("../ExpressionFunctions/aggregatedScalarExpressionFunctions");
+const aggregatedBooleanExpressionFunctions_1 = require("../ExpressionFunctions/aggregatedBooleanExpressionFunctions");
 const AggregatedScalarLiveValue_1 = require("./AggregatedScalarLiveValue");
+const booleanExpressionFunctions_1 = require("../ExpressionFunctions/booleanExpressionFunctions");
+const scalarExpressionFunctions_1 = require("../ExpressionFunctions/scalarExpressionFunctions");
+const observableExpressionFunctions_1 = require("../ExpressionFunctions/observableExpressionFunctions");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 class QueryLanguageService {
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
@@ -16,7 +22,7 @@ class QueryLanguageService {
         this.cacheModuleSpecificExpressionFunctions = new Map();
     }
     evaluateBooleanExpression(expression, module, rowNode) {
-        const moduleExpressionFunctions = this.getModuleExpressionFunctions(module);
+        const moduleExpressionFunctions = this.getModuleExpressionFunctionsMap(module);
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         return parser.evaluate(expression, {
             node: rowNode,
@@ -30,7 +36,7 @@ class QueryLanguageService {
         return this.evaluateBooleanExpression(expression, module, rowNode);
     }
     evaluateAggregatedScalarExpression(expression, module) {
-        const aggregatedScalarFunctions = this.getModuleExpressionFunctions(module).aggregatedScalarFunctions;
+        const aggregatedScalarFunctions = this.getModuleExpressionFunctionsMap(module).aggregatedScalarFunctions;
         return parser.evaluate(expression, {
             node: null,
             adaptableApi: this.adaptableApi,
@@ -39,7 +45,7 @@ class QueryLanguageService {
         });
     }
     evaluateObservableExpression(reactiveExpression, module) {
-        const moduleExpressionFunctions = this.getModuleExpressionFunctions(module);
+        const moduleExpressionFunctions = this.getModuleExpressionFunctionsMap(module);
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         const reactiveExpression$ = parser.evaluate(reactiveExpression, {
             node: reactiveExpression,
@@ -51,12 +57,12 @@ class QueryLanguageService {
         return reactiveExpression$;
     }
     evaluateAggregatedBooleanExpression(aggregationExpression, module) {
-        const moduleExpressionFunctions = this.getModuleExpressionFunctions(module);
-        const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
+        const moduleExpressionFunctionsMap = this.getModuleExpressionFunctionsMap(module);
+        const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctionsMap);
         const aggregationEvaluation = parser.evaluate(aggregationExpression, {
             node: aggregationExpression,
             adaptableApi: this.adaptableApi,
-            functions: moduleExpressionFunctions.aggregatedBooleanFunctions,
+            functions: moduleExpressionFunctionsMap.aggregatedBooleanFunctions,
             whereClauseFunctions: booleanAndScalarFunctions,
             evaluateCustomQueryVariable: this.evaluateCustomQueryVariable,
         });
@@ -89,7 +95,7 @@ class QueryLanguageService {
             }
             const { ast } = parser.parse(expression.trim());
             const rootFn = ast[ast.length - 1];
-            const moduleExpressionFunctions = this.getModuleExpressionFunctions(module);
+            const moduleExpressionFunctions = this.getModuleExpressionFunctionsMap(module);
             const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
             if (rootFn.type === undefined || booleanAndScalarFunctions[rootFn.type] === undefined) {
                 const result = {
@@ -99,7 +105,7 @@ class QueryLanguageService {
                 this.cacheBooleanValidation.set(cacheKey, result);
                 return result;
             }
-            if (!booleanAndScalarFunctions[rootFn.type].isPredicate) {
+            if (booleanAndScalarFunctions[rootFn.type].returnType !== 'boolean') {
                 const result = {
                     isValid: false,
                     errorMessage: `provided function ${rootFn === null || rootFn === void 0 ? void 0 : rootFn.type} is not a predicate`,
@@ -179,7 +185,7 @@ class QueryLanguageService {
             if (evaluationResult.type !== 'aggregationBoolean') {
                 const result = {
                     isValid: false,
-                    errorMessage: 'provided AggregatedBBoolean expression does not evaluate to a supported aggregation',
+                    errorMessage: 'provided AggregatedBoolean expression does not evaluate to a supported aggregation',
                 };
                 this.cacheAggregatedBooleanValidation.set(cacheKey, result);
                 return result;
@@ -261,50 +267,93 @@ class QueryLanguageService {
         let result = expression;
         const columnIds = this.getColumnsFromExpression(expression);
         columnIds.forEach((columnId) => {
-            const columnFriendlyName = this.adaptableApi.columnApi.getFriendlyNameFromColumnId(columnId);
+            const columnFriendlyName = this.adaptableApi.columnApi.getFriendlyNameForColumnId(columnId);
             result = result.split(columnId).join(columnFriendlyName);
         });
         return result;
     }
     // Returns the ExpressionFunctions available for the given Module as specified in the `QueryLanguageOptions.moduleExpressionFunctions`
     // if there are no specific functions defined, it falls back to the default values
-    getModuleExpressionFunctions(module) {
-        var _a, _b, _c, _d, _e, _f, _g;
+    getModuleExpressionFunctionsMap(module) {
+        var _a, _b, _c;
+        const expressionOptions = this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions;
+        if (module) {
+            let cachedResult = this.cacheModuleSpecificExpressionFunctions.get(module);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
+        const generalBooleanExpressionFunctions = this.extractMappedExpressionFunctions(booleanExpressionFunctions_1.booleanExpressionFunctions, expressionOptions.systemBooleanFunctions, expressionOptions.customBooleanFunctions);
+        const generalScalarExpressionFunctions = this.extractMappedExpressionFunctions(scalarExpressionFunctions_1.scalarExpressionFunctions, expressionOptions.systemScalarFunctions, expressionOptions.customScalarFunctions);
+        const generalObservableExpressionFunctions = this.extractMappedExpressionFunctions(observableExpressionFunctions_1.observableExpressionFunctions, expressionOptions.systemObservableFunctions);
+        const generalAggregatedBooleanExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedBooleanExpressionFunctions_1.aggregatedBooleanExpressionFunctions, expressionOptions.systemAggregatedBooleanFunctions);
+        const generalAggregatedScalarExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions, expressionOptions.systemAggregatedScalarFunctions);
         if (!module) {
             (0, LoggingHelper_1.LogAdaptableInfo)(`QueryLanguageService.getModuleExpressionFunctions() was called with an undefined 'module' param, this should never happen`);
             return {
-                booleanFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                    .defaultBooleanFunctions,
-                scalarFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                    .defaultScalarFunctions,
-                observableFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                    .defaultObservableFunctions,
-                aggregatedBooleanFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                    .defaultAggregatedBooleanFunctions,
-                aggregatedScalarFunctions: this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                    .defaultAggregatedScalarFunctions,
+                booleanFunctions: generalBooleanExpressionFunctions,
+                scalarFunctions: generalScalarExpressionFunctions,
+                observableFunctions: generalObservableExpressionFunctions,
+                aggregatedBooleanFunctions: generalAggregatedBooleanExpressionFunctions,
+                aggregatedScalarFunctions: generalAggregatedScalarExpressionFunctions,
+            };
+        }
+        let moduleExpressionFunctions;
+        if (typeof expressionOptions.moduleExpressionFunctions === 'function') {
+            const context = {
+                adaptableApi: this.adaptableApi,
+                module,
+                availableBooleanFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalBooleanExpressionFunctions),
+                availableScalarFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalScalarExpressionFunctions),
+                availableObservableFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalObservableExpressionFunctions),
+                availableAggregatedBooleanFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalAggregatedBooleanExpressionFunctions),
+                availableAggregatedScalarFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalAggregatedScalarExpressionFunctions),
             };
+            moduleExpressionFunctions = (_a = expressionOptions.moduleExpressionFunctions(context)) !== null && _a !== void 0 ? _a : {};
         }
-        let cachedResult = this.cacheModuleSpecificExpressionFunctions.get(module);
-        if (cachedResult) {
-            return cachedResult;
+        else {
+            moduleExpressionFunctions = (_c = (_b = expressionOptions.moduleExpressionFunctions) === null || _b === void 0 ? void 0 : _b[module]) !== null && _c !== void 0 ? _c : {};
         }
-        const moduleSpecificOptions = (_b = (_a = this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-            .moduleExpressionFunctions) === null || _a === void 0 ? void 0 : _a[module]) !== null && _b !== void 0 ? _b : {};
-        const moduleSpecificFunctions = {
-            booleanFunctions: (_c = moduleSpecificOptions.booleanFunctions) !== null && _c !== void 0 ? _c : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                .defaultBooleanFunctions,
-            scalarFunctions: (_d = moduleSpecificOptions.scalarFunctions) !== null && _d !== void 0 ? _d : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                .defaultScalarFunctions,
-            observableFunctions: (_e = moduleSpecificOptions.observableFunctions) !== null && _e !== void 0 ? _e : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                .defaultObservableFunctions,
-            aggregatedBooleanFunctions: (_f = moduleSpecificOptions.aggregatedBooleanFunctions) !== null && _f !== void 0 ? _f : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                .defaultAggregatedBooleanFunctions,
-            aggregatedScalarFunctions: (_g = moduleSpecificOptions.aggregatedScalarFunctions) !== null && _g !== void 0 ? _g : this.adaptableApi.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
-                .defaultAggregatedScalarFunctions,
+        const moduleExpressionFunctionsMap = {
+            booleanFunctions: this.extractMappedExpressionFunctions(generalBooleanExpressionFunctions, moduleExpressionFunctions.systemBooleanFunctions, moduleExpressionFunctions.customBooleanFunctions),
+            scalarFunctions: this.extractMappedExpressionFunctions(generalScalarExpressionFunctions, moduleExpressionFunctions.systemScalarFunctions, moduleExpressionFunctions.customScalarFunctions),
+            observableFunctions: this.extractMappedExpressionFunctions(generalObservableExpressionFunctions, moduleExpressionFunctions.systemObservableFunctions),
+            aggregatedBooleanFunctions: this.extractMappedExpressionFunctions(generalAggregatedBooleanExpressionFunctions, moduleExpressionFunctions.systemAggregatedBooleanFunctions),
+            aggregatedScalarFunctions: this.extractMappedExpressionFunctions(generalAggregatedScalarExpressionFunctions, moduleExpressionFunctions.systemAggregatedScalarFunctions),
         };
-        this.cacheModuleSpecificExpressionFunctions.set(module, moduleSpecificFunctions);
-        return moduleSpecificFunctions;
+        this.cacheModuleSpecificExpressionFunctions.set(module, moduleExpressionFunctionsMap);
+        return moduleExpressionFunctionsMap;
+    }
+    extractMappedExpressionFunctions(availableExpressionFunctions, systemFunctions, customFunctions) {
+        const systemFunctionNames = typeof systemFunctions === 'function'
+            ? systemFunctions({
+                adaptableApi: this.adaptableApi,
+                availableExpressionFunctionNames: (0, TypeExtensions_1.getTypedKeys)(availableExpressionFunctions),
+            })
+            : systemFunctions;
+        let generalExpressionFunctions = {};
+        // add system functions
+        if (Array.isArray(systemFunctionNames)) {
+            // add only system functions specified by user
+            systemFunctionNames.forEach((systemFunctionName) => {
+                generalExpressionFunctions[systemFunctionName] =
+                    availableExpressionFunctions[systemFunctionName];
+            });
+        }
+        else {
+            // add ALL system functions
+            generalExpressionFunctions = Object.assign({}, availableExpressionFunctions);
+        }
+        const customFunctionDefinitions = typeof customFunctions === 'function'
+            ? customFunctions({
+                adaptableApi: this.adaptableApi,
+                availableExpressionFunctionNames: (0, TypeExtensions_1.getTypedKeys)(generalExpressionFunctions),
+            })
+            : customFunctions;
+        if (customFunctionDefinitions) {
+            generalExpressionFunctions = Object.assign(Object.assign({}, generalExpressionFunctions), customFunctionDefinitions);
+        }
+        return generalExpressionFunctions;
     }
     evaluateCustomQueryVariable(functionName, args) {
         var _a, _b, _c;
@@ -317,8 +366,8 @@ class QueryLanguageService {
             ? customQueryVariableDefinition(context)
             : customQueryVariableDefinition;
     }
-    getBooleanAndScalarFunctions(moduleExpressionFunctions) {
-        return Object.assign(Object.assign({}, moduleExpressionFunctions.booleanFunctions), moduleExpressionFunctions.scalarFunctions);
+    getBooleanAndScalarFunctions(moduleExpressionFunctionsMap) {
+        return Object.assign(Object.assign({}, moduleExpressionFunctionsMap.booleanFunctions), moduleExpressionFunctionsMap.scalarFunctions);
     }
     getExpressionCacheKey(expression, module) {
         return `${module}::${expression}`;

package/src/Utilities/Services/ReportService.js

@@ -91,7 +91,7 @@ class ReportService {
     }
     GetReportColumnScopeShortDescription(report) {
         var _a, _b;
-        if (this.adaptableApi.exportApi.isCustomReport(report)) {
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
             return ['[Custom Columns]'];
         }
         switch (report.ReportColumnScope) {
@@ -103,13 +103,13 @@ class ReportService {
                 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.getFriendlyNameFromColumnId(columnId)) !== null && _a !== void 0 ? _a : columnId; });
+                    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.isCustomReport(report)) {
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
             return '[Custom Columns]';
         }
         switch (report.ReportColumnScope) {
@@ -124,7 +124,7 @@ class ReportService {
         }
     }
     GetReportExpressionDescription(report, cols) {
-        if (this.adaptableApi.exportApi.isCustomReport(report)) {
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
             return '[Custom Data]';
         }
         if (this.IsSystemReport(report.Name)) {
@@ -160,7 +160,7 @@ class ReportService {
     GetReportColumnsForReport(report, includePrimaryKey = false) {
         let reportColumns = [];
         let gridColumns = this.adaptableApi.columnApi.getColumns();
-        if (this.adaptableApi.exportApi.isCustomReport(report)) {
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
             return reportColumns;
         }
         // first get the cols depending on the Column Scope
@@ -180,7 +180,7 @@ class ReportService {
                 break;
             case 'ScopeColumns':
                 if ('ColumnIds' in report.Scope) {
-                    reportColumns = report.Scope.ColumnIds.map((columnId) => this.adaptableApi.columnApi.getColumnFromId(columnId)).filter((c) => c);
+                    reportColumns = report.Scope.ColumnIds.map((columnId) => this.adaptableApi.columnApi.getColumnWithColumnId(columnId)).filter((c) => c);
                 }
                 else {
                     reportColumns = this.adaptableApi.scopeApi.getColumnsForScope(report.Scope);
@@ -204,8 +204,8 @@ class ReportService {
             friendlyName: column.friendlyName,
             dataType: column.dataType,
         }));
-        if (this.adaptableApi.exportApi.isCustomReport(report)) {
-            return this.adaptableApi.exportApi.runCustomReport(report.Name);
+        if (this.adaptableApi.exportApi.isServerReport(report)) {
+            return this.adaptableApi.exportApi.runServerReport(report.Name);
         }
         if (ArrayExtensions_1.default.IsNullOrEmpty(columns)) {
             return { columns: [], rows: [] };
@@ -306,7 +306,7 @@ class ReportService {
         if (StringExtensions_1.default.IsNullOrEmpty(cellRawValue)) {
             return cellRawValue;
         }
-        const columnType = this.adaptableApi.columnApi.getColumnDataTypeFromColumnId(columnId);
+        const columnType = this.adaptableApi.columnApi.getColumnDataTypeForColumnId(columnId);
         // if this is a date column and there is a custom export date format provided, that will take precedence
         if (columnType === 'Date' && !!this.getCustomExportDateFormat()) {
             const exportDateFormat = this.getCustomExportDateFormat();

package/src/Utilities/Services/RowEditService.d.ts

@@ -1,26 +1,7 @@
 import { IRowEditService } from './Interface/IRowEditService';
-import { RowNode } from '@ag-grid-community/core';
 import { AdaptableApi } from '../../Api/AdaptableApi';
-import { AdaptableForm } from '../../PredefinedConfig/Common/AdaptableForm';
-import { CreateActionRowContext, EditActionRowContext } from '../../AdaptableOptions/ActionOptions';
 export declare class RowEditService implements IRowEditService {
     private adaptableApi;
-    private adaptableInstance;
-    private rowEditFormOptions;
     constructor(adaptableApi: AdaptableApi);
-    buildRowEditForm(rowNode: RowNode): AdaptableForm<EditActionRowContext>;
-    buildRowCreateForm(clonedRowNode?: RowNode): AdaptableForm<CreateActionRowContext>;
-    private buildActionRow;
-    private getFormTitle;
-    private getFormDescription;
-    private buildFormParamContext;
-    private buildActionRowFields;
-    private buidActionRowButtons;
-    private isColumnEditable;
-    private buildFormField;
-    private getFormFieldLabel;
-    private buildFormFieldLabelContext;
-    private getFieldTypeFromColumnType;
-    private getFieldValueOptions;
     private autoHandleActionRowButtons;
 }

package/src/Utilities/Services/RowEditService.js

@@ -1,172 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RowEditService = void 0;
+// @ts-ignore
 class RowEditService {
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
-        this.adaptableInstance = this.adaptableApi.internalApi.getAdaptableInstance();
-        this.rowEditFormOptions =
-            this.adaptableApi.internalApi.getAdaptableInstance().adaptableOptions.actionOptions.actionRowFormOptions;
-        if (this.adaptableInstance.adaptableOptions.actionOptions.autoHandleActionRowButtons) {
-            this.adaptableInstance.api.eventApi.on('ActionRowSubmitted', (eventInfo) => this.autoHandleActionRowButtons(eventInfo));
+        const adaptableInstance = this.adaptableApi.internalApi.getAdaptableInstance();
+        if (adaptableInstance.adaptableOptions.actionOptions.actionRowButtonOptions.autoHandle) {
+            adaptableInstance.api.eventApi.on('ActionRowSubmitted', (eventInfo) => this.autoHandleActionRowButtons(eventInfo));
         }
     }
-    buildRowEditForm(rowNode) {
-        return this.buildActionRow('rowEdited', rowNode);
-    }
-    buildRowCreateForm(clonedRowNode) {
-        return this.buildActionRow('rowCreated', clonedRowNode);
-    }
-    buildActionRow(type, rowNode) {
-        const formFields = this.buildActionRowFields(type, rowNode);
-        const formButtons = this.buidActionRowButtons(type, rowNode);
-        const formTitle = this.getFormTitle(type, rowNode);
-        const formDescription = this.getFormDescription(type, rowNode);
-        const actionRowForm = {
-            title: formTitle,
-            description: formDescription,
-            fields: formFields,
-            buttons: formButtons,
-        };
-        return actionRowForm;
-    }
-    getFormTitle(type, rowNode) {
-        if (this.rowEditFormOptions.formTitle == undefined) {
-            return type === 'rowCreated' ? 'Create New Row' : 'Edit Row';
-        }
-        return typeof this.rowEditFormOptions.formTitle === 'function'
-            ? this.rowEditFormOptions.formTitle(this.buildFormParamContext(type, rowNode))
-            : this.rowEditFormOptions.formTitle;
-    }
-    getFormDescription(type, rowNode) {
-        return typeof this.rowEditFormOptions.formDescription === 'function'
-            ? this.rowEditFormOptions.formDescription(this.buildFormParamContext(type, rowNode))
-            : this.rowEditFormOptions.formDescription;
-    }
-    buildFormParamContext(type, rowNode) {
-        return {
-            rowNode,
-            adaptableApi: this.adaptableApi,
-            type: type,
-        };
-    }
-    buildActionRowFields(type, rowNode) {
-        const relevantColumns = this.adaptableApi.columnApi
-            .getColumns()
-            .filter((column) => {
-            // if there is NO rowNode, do NOT display the non-editable fields as they will be empty
-            return !!rowNode || this.isColumnEditable(column, rowNode);
-        })
-            .filter((column) => !this.adaptableApi.columnApi.isActionRowButtonColumn(column.columnId));
-        return relevantColumns.map((column) => this.buildFormField(type, column, rowNode));
-    }
-    buidActionRowButtons(type, rowNode) {
-        // 1. check if there are custom user provided buttons
-        if (Array.isArray(this.rowEditFormOptions.formButtons)) {
-            return this.rowEditFormOptions.formButtons;
-        }
-        // 2. else return the standard ones
-        const cancelButton = {
-            label: 'Cancel',
-            buttonStyle: {
-                variant: 'raised',
-                tone: 'neutral',
-            },
-        };
-        const saveButton = {
-            label: 'Save',
-            buttonStyle: {
-                variant: 'raised',
-                tone: 'success',
-            },
-            onClick: (button, context) => {
-                var _a, _b;
-                const eventInfo = type === 'rowCreated'
-                    ? {
-                        type: 'rowCreated',
-                        formData: context.formData,
-                        adaptableApi: context.adaptableApi,
-                        clonedRowNode: rowNode,
-                    }
-                    : {
-                        type: 'rowEdited',
-                        formData: context.formData,
-                        rowNode: rowNode,
-                        adaptableApi: context.adaptableApi,
-                    };
-                this.adaptableApi.eventApi.emit('ActionRowSubmitted', eventInfo);
-                (_b = (_a = this.adaptableInstance.adaptableOptions.actionOptions.actionRowFormOptions).onFormSubmit) === null || _b === void 0 ? void 0 : _b.call(_a, eventInfo);
-            },
-        };
-        return [cancelButton, saveButton];
-    }
-    isColumnEditable(column, rowNode) {
-        return rowNode
-            ? this.adaptableInstance.isCellEditable(rowNode, this.adaptableInstance.getAgGridColumnForColumnId(column.columnId))
-            : !column.readOnly;
-    }
-    buildFormField(type, column, rowNode) {
-        const isColumnEditable = this.isColumnEditable(column, rowNode);
-        const fieldValueOptions = this.getFieldValueOptions(column, rowNode);
-        const fieldType = isColumnEditable
-            ? !!(fieldValueOptions === null || fieldValueOptions === void 0 ? void 0 : fieldValueOptions.length)
-                ? 'select'
-                : this.getFieldTypeFromColumnType(column)
-            : 'textOutput';
-        const defaultValue = rowNode
-            ? isColumnEditable
-                ? this.adaptableInstance.getRawValueFromRowNode(rowNode, column.columnId)
-                : this.adaptableInstance.getDisplayValueFromRowNode(rowNode, column.columnId)
-            : null;
-        return {
-            label: this.getFormFieldLabel(type, column, rowNode),
-            name: column.columnId,
-            defaultValue,
-            fieldType,
-            options: fieldValueOptions,
-        };
-    }
-    getFormFieldLabel(type, column, rowNode) {
-        const customFieldLabel = typeof this.rowEditFormOptions.formFieldLabel === 'function'
-            ? this.rowEditFormOptions.formFieldLabel(this.buildFormFieldLabelContext(type, column, rowNode))
-            : undefined;
-        return customFieldLabel !== null && customFieldLabel !== void 0 ? customFieldLabel : column.friendlyName;
-    }
-    buildFormFieldLabelContext(type, column, rowNode) {
-        return {
-            rowNode,
-            column,
-            adaptableApi: this.adaptableApi,
-            type: type,
-        };
-    }
-    getFieldTypeFromColumnType(column) {
-        switch (column.dataType) {
-            case 'Boolean':
-                return 'checkbox';
-            case 'Date':
-                return 'date';
-            case 'Number':
-                return 'number';
-            default:
-                // everything else is a plain text input
-                return 'text';
-        }
-    }
-    getFieldValueOptions(column, rowNode) {
-        const editLookUpItem = this.adaptableApi.userInterfaceApi.getEditLookUpItemForColumn(column);
-        if (!editLookUpItem) {
-            return;
-        }
-        const gridCell = rowNode
-            ? this.adaptableInstance.getGridCellFromRowNode(rowNode, column.columnId)
-            : undefined;
-        const editLookUpValues = this.adaptableApi.internalApi.getEditLookUpValuesForColumn(editLookUpItem, column, gridCell);
-        return editLookUpValues === null || editLookUpValues === void 0 ? void 0 : editLookUpValues.map((value) => ({
-            value,
-            label: value,
-        }));
-    }
     autoHandleActionRowButtons(actionRowSubmittedInfo) {
         const { adaptableApi } = actionRowSubmittedInfo;
         if (actionRowSubmittedInfo.type === 'rowEdited') {
@@ -182,7 +25,7 @@ class RowEditService {
         if (actionRowSubmittedInfo.type === 'rowCreated') {
             const { formData } = actionRowSubmittedInfo;
             const setPrimaryKeyValueFunction = adaptableApi.internalApi.getAdaptableInstance().adaptableOptions.actionOptions
-                .setPrimaryKeyValue;
+                .actionRowButtonOptions.setPrimaryKeyValue;
             const newRowData = typeof setPrimaryKeyValueFunction === 'function'
                 ? setPrimaryKeyValueFunction({
                     rowData: formData,

package/src/Utilities/Services/TeamSharingService.js

@@ -74,7 +74,7 @@ class TeamSharingService {
                 return importInfo === null || importInfo === void 0 ? void 0 : importInfo.AddAction(Entity);
             }
         };
-        const existingSharedEntities = this.adaptableApi.internalApi.getLocalTeamSharingEntities();
+        const existingSharedEntities = this.adaptableApi.teamSharingApi.internalApi.getLocalTeamSharingEntities();
         const sharedEntityDependencyTree = this.getSharedEntityDependencyTree(importedSharedEntity, existingSharedEntities);
         const importSteps = sharedEntityDependencyTree.map((sharedEntity) => ({
             sharedEntity,
@@ -89,7 +89,7 @@ class TeamSharingService {
         return [localRevision, remoteRevision];
     }
     getStaleActiveSharedEntities() {
-        const sharedEntities = this.adaptableApi.internalApi.getLocalTeamSharingEntities();
+        const sharedEntities = this.adaptableApi.teamSharingApi.internalApi.getLocalTeamSharingEntities();
         const activeEntities = this.adaptableApi.internalApi.getState().TeamSharing.ActiveSharedEntityMap;
         const result = {};
         sharedEntities
@@ -122,7 +122,7 @@ class TeamSharingService {
             if (updateNotification === 'SystemStatus') {
                 this.adaptableApi.systemStatusApi.setInfoSystemStatus(`TeamSharing: ${notificationMessage}`);
             }
-            this.adaptableApi.teamSharingApi.fireTeamSharingEntityChangedEvent(sharedEntityActiveInfo.sharedEntity);
+            this.adaptableApi.teamSharingApi.internalApi.fireTeamSharingEntityChangedEvent(sharedEntityActiveInfo.sharedEntity);
         });
     }
     destroy() {

package/src/Utilities/Services/ValidationService.js

@@ -17,7 +17,7 @@ class ValidationService {
         if (cellDataChangedInfo.oldValue == cellDataChangedInfo.newValue) {
             return [];
         }
-        let editingRules = this.adaptableApi.alertApi
+        let editingRules = this.adaptableApi.alertApi.internalApi
             .getAlertDefinitionsWithPreventEdit()
             .filter((v) => this.adaptableApi.scopeApi.isColumnInScope(cellDataChangedInfo.column, v.Scope));
         let failedValidations = [];
@@ -51,17 +51,18 @@ class ValidationService {
                 alertDefinition: failedRules[0],
                 cellDataChangedInfo: cellDataChangedInfo,
             };
-            this.adaptableApi.alertApi.publishAlertFiredEvent(alert);
+            this.adaptableApi.alertApi.internalApi.publishAlertFiredEvent(alert);
             failedRules.forEach((alertDefinition) => {
-                const alert = ObjectFactory_1.default.CreateCellChangedAlert(cellDataChangedInfo.column.friendlyName, this.adaptableApi.alertApi.getAlertDescription(alertDefinition, cellDataChangedInfo), alertDefinition, cellDataChangedInfo);
-                this.adaptableApi.alertApi.displayAlert(alert);
+                const alert = ObjectFactory_1.default.CreateCellChangedAlert(cellDataChangedInfo.column.friendlyName, this.adaptableApi.alertApi.internalApi.getAlertDescription(alertDefinition, cellDataChangedInfo), alertDefinition, cellDataChangedInfo);
+                this.adaptableApi.alertApi.showAdaptableAlert(alert);
             });
             return false;
         }
         return true;
     }
     IsAlertDefinitionTriggered(alertDefinition, dataChangedEvent) {
-        return this.adaptableApi.predicateApi.handlePredicate(alertDefinition.Rule.Predicate, {
+        var _a;
+        return this.adaptableApi.predicateApi.handlePredicates((_a = alertDefinition.Rule) === null || _a === void 0 ? void 0 : _a.Predicates, {
             value: dataChangedEvent.newValue,
             oldValue: dataChangedEvent.oldValue,
             displayValue: this.adaptableApi.gridApi.getDisplayValueFromRowNode(dataChangedEvent.rowNode, dataChangedEvent.column.columnId),
@@ -88,7 +89,7 @@ class ValidationService {
                     if (!row) {
                         return;
                     }
-                    row[(_b = this.adaptableApi.columnApi.getAgGridColumnFieldForAdaptableColumn(cellDataChangedInfo.column.columnId)) !== null && _b !== void 0 ? _b : cellDataChangedInfo.column.columnId] = validationResult.NewValue;
+                    row[(_b = this.adaptableApi.columnApi.internalApi.getAgGridColumnFieldForAdaptableColumn(cellDataChangedInfo.column.columnId)) !== null && _b !== void 0 ? _b : cellDataChangedInfo.column.columnId] = validationResult.NewValue;
                     this.adaptableApi.gridApi.updateGridData([row]);
                     if (StringExtensions_1.default.IsNotNullOrEmpty(validationResult.ValidationMessage) &&
                         this.adaptableApi.internalApi.getAdaptableOptions().editOptions
@@ -102,9 +103,10 @@ class ValidationService {
         };
     }
     createValidationDescription(alertDefinition) {
+        var _a, _b;
         return (this.adaptableApi.scopeApi.getScopeDescription(alertDefinition.Scope) +
             ' ' +
-            this.adaptableApi.predicateApi.predicateToString(alertDefinition.Rule.Predicate));
+            ((_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 ')));
     }
     createValidationMessage(alertDefinition) {
         let returnMessage = this.createValidationDescription(alertDefinition);

package/src/Utilities/license/LicenseDetails.d.ts

@@ -2,9 +2,9 @@ export declare type LicenseDetails = {
     start: Date;
     end: Date;
     owner: string;
+    appName: string;
     trial: boolean;
     skipAirtable?: boolean;
-    count?: number;
     timestamp?: number;
     ref: string;
 };

package/src/Utilities/license/decode.d.ts

@@ -1,4 +1,5 @@
 import { LicenseDetails } from './LicenseDetails';
+export declare const GENERIC_APP_NAME = "GenericAdaptableApp";
 export declare const fieldsToLicenseDetails: (fields: {
     name: string;
     value: string;