@adaptabletools/adaptable 12.0.0-canary.2 → 12.0.0-canary.5

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -9,18 +9,21 @@ const toNumber_1 = tslib_1.__importDefault(require("lodash/toNumber"));
 const evaluator_1 = require("../../parser/src/evaluator");
 // string functions may be case (in)sensitive, see internalApi.isTextComparisonCaseSensitive()
 // if case is insensitive, we convert ALL involved strings to lower case
-exports.getStringValues = (context, ...stringArguments) => {
+const getStringValues = (context, ...stringArguments) => {
     return exports.isTextSearchCaseInsensitive(context)
         ? stringArguments.map((string) => string.toLowerCase())
         : stringArguments;
 };
-exports.getStringValue = (context, stringArgument) => {
+exports.getStringValues = getStringValues;
+const getStringValue = (context, stringArgument) => {
     return exports.isTextSearchCaseInsensitive(context) ? stringArgument.toLowerCase() : stringArgument;
 };
-exports.isTextSearchCaseInsensitive = (context) => !context.api.internalApi.isTextComparisonCaseSensitive();
+exports.getStringValue = getStringValue;
+const isTextSearchCaseInsensitive = (context) => !context.api.internalApi.isTextComparisonCaseSensitive();
+exports.isTextSearchCaseInsensitive = isTextSearchCaseInsensitive;
 // returns an observable which filters the source$ emissions and emits only if the CellDataChangedInfo relates to the given column
 // optionally, if a filter function (where clause) is provided, it is also evaluated
-exports.getDataChangeLog$ = (context, columnNameFilter) => {
+const getDataChangeLog$ = (context, columnNameFilter) => {
     let dataChangeLog$ = context.api.internalApi.getDataService().dataChangeLog$;
     // filter only the given column changes
     dataChangeLog$ = dataChangeLog$.pipe(operators_1.filter((dataChangeLog) => dataChangeLog.column.columnId === columnNameFilter));
@@ -30,7 +33,8 @@ exports.getDataChangeLog$ = (context, columnNameFilter) => {
     }
     return dataChangeLog$;
 };
-exports.handleWhereFunction = (args, context) => {
+exports.getDataChangeLog$ = getDataChangeLog$;
+const handleWhereFunction = (args, context) => {
     const reactiveExpressionNode = args[0];
     const whereClauseExpressionNode = args[1];
     const filterFn = (rowNode) => {
@@ -49,10 +53,12 @@ exports.handleWhereFunction = (args, context) => {
         filterFn,
     });
 };
-exports.extractColumnParameter = (consumingFunctionName, args) => {
+exports.handleWhereFunction = handleWhereFunction;
+const extractColumnParameter = (consumingFunctionName, args) => {
     return exports.extractParameter(consumingFunctionName, 'config', ['COL'], args);
 };
-exports.extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, isOptional) => {
+exports.extractColumnParameter = extractColumnParameter;
+const extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, isOptional) => {
     const result = args.filter((arg) => (arg === null || arg === void 0 ? void 0 : arg.type) === allowedType && allowedOperands.includes(arg === null || arg === void 0 ? void 0 : arg.name));
     if (isOptional && !result.length) {
         return;
@@ -65,7 +71,8 @@ exports.extractParameter = (consumingFunctionName, allowedType, allowedOperands,
     }
     return result[0];
 };
-exports.handleColumnFunction = (args, context) => {
+exports.extractParameter = extractParameter;
+const handleColumnFunction = (args, context) => {
     if (StringExtensions_1.default.IsNullOrEmpty(args[0])) {
         throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `no column name is provided`);
     }
@@ -77,16 +84,19 @@ exports.handleColumnFunction = (args, context) => {
     };
     return result;
 };
-exports.getNumericValue = (input) => {
+exports.handleColumnFunction = handleColumnFunction;
+const getNumericValue = (input) => {
     const numericValue = toNumber_1.default(input);
     return isNaN(numericValue) ? 0 : numericValue;
 };
-exports.validateColumnType = (columnId, validColumnTypes, consumingFunction, api) => {
+exports.getNumericValue = getNumericValue;
+const validateColumnType = (columnId, validColumnTypes, consumingFunction, api) => {
     const columnType = api.columnApi.getColumnDataTypeFromColumnId(columnId);
     if (!validColumnTypes.some((validType) => validType === columnType)) {
         throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunction, `expects a column of type ${validColumnTypes.join(' or ')}`);
     }
 };
+exports.validateColumnType = validateColumnType;
 const validateColumnId = (columnId, api) => {
     const column = api.columnApi.getColumnFromId(columnId);
     if (!column) {

package/src/Utilities/Extensions/TypeExtensions.d.ts

@@ -43,4 +43,34 @@ export declare type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<
 }[Keys];
 /** Similar to the builtin Extract, but checks the filter strictly */
 export declare type StrictExtract<T, U extends Partial<T>> = Extract<T, U>;
+/**
+ * DeepRequired
+ *
+ * from https://github.com/piotrwitek/utility-types
+ *
+ * @desc Required that works for deeply nested structure
+ * @example
+ *   // Expect: {
+ *   //   first: {
+ *   //     second: {
+ *   //       name: string;
+ *   //     };
+ *   //   };
+ *   // }
+ *   type NestedProps = {
+ *     first?: {
+ *       second?: {
+ *         name?: string;
+ *       };
+ *     };
+ *   };
+ *   type RequiredNestedProps = DeepRequired<NestedProps>;
+ */
+export declare type DeepRequired<T> = T extends (...args: any[]) => any ? T : T extends any[] ? _DeepRequiredArray<T[number]> : T extends object ? _DeepRequiredObject<T> : T;
+export interface _DeepRequiredArray<T> extends Array<DeepRequired<NonUndefined<T>>> {
+}
+export declare type _DeepRequiredObject<T> = {
+    [P in keyof T]-?: DeepRequired<NonUndefined<T[P]>>;
+};
+export declare type NonUndefined<A> = A extends undefined ? never : A;
 export {};

package/src/Utilities/Helpers/AdaptableHelper.d.ts

@@ -9,15 +9,13 @@ export declare function initPredefinedConfigWithUuids(predefinedConfig: Predefin
 export declare function checkValidPrimaryKey(adaptable: IAdaptable): boolean;
 export declare function AdaptableObjectExistsInState(array: AdaptableObject[], itemToCheck: AdaptableObject): boolean;
 export declare function getAppropriateAccessLevel(adaptableObject: AdaptableObject, moduleAccessLevel: AccessLevel): AccessLevel;
-export declare function checkAdaptableOptions(adaptableOptions: AdaptableOptions): void;
 export declare function runAdaptableComparerFunction(columnId: string, columnValues: any[], adaptable: IAdaptable): AdaptableComparerFunction;
 export declare function addAdaptableObjectUuidAndSource(adaptableObject: AdaptableObject): AdaptableObject;
 export declare const AdaptableHelper: {
-    assignadaptableOptions: typeof assignAdaptableOptions;
+    assignAdaptableOptions: typeof assignAdaptableOptions;
     initPredefinedConfigWithUuids: typeof initPredefinedConfigWithUuids;
     checkValidPrimaryKey: typeof checkValidPrimaryKey;
     AdaptableObjectExistsInState: typeof AdaptableObjectExistsInState;
-    checkAdaptableOptions: typeof checkAdaptableOptions;
     runAdaptableComparerFunction: typeof runAdaptableComparerFunction;
     getAppropriateAccessLevel: typeof getAppropriateAccessLevel;
     addUuidAndSource: typeof addAdaptableObjectUuidAndSource;

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptableHelper = exports.addAdaptableObjectUuidAndSource = exports.runAdaptableComparerFunction = exports.checkAdaptableOptions = exports.getAppropriateAccessLevel = exports.AdaptableObjectExistsInState = exports.checkValidPrimaryKey = exports.initPredefinedConfigWithUuids = exports.assignAdaptableOptions = void 0;
+exports.AdaptableHelper = exports.addAdaptableObjectUuidAndSource = exports.runAdaptableComparerFunction = exports.getAppropriateAccessLevel = exports.AdaptableObjectExistsInState = exports.checkValidPrimaryKey = exports.initPredefinedConfigWithUuids = exports.assignAdaptableOptions = void 0;
 const tslib_1 = require("tslib");
 const cloneDeepWith_1 = tslib_1.__importDefault(require("lodash/cloneDeepWith"));
 const isPlainObject_1 = tslib_1.__importDefault(require("lodash/isPlainObject"));
@@ -10,7 +10,8 @@ const DefaultAdaptableOptions_1 = require("../Defaults/DefaultAdaptableOptions")
 function assignAdaptableOptions(adaptableOptions) {
     var _a;
     const returnedAdaptableOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions, adaptableOptions);
-    returnedAdaptableOptions.adaptableStateKey = (_a = returnedAdaptableOptions.adaptableStateKey) !== null && _a !== void 0 ? _a : returnedAdaptableOptions.adaptableId;
+    returnedAdaptableOptions.adaptableStateKey =
+        (_a = returnedAdaptableOptions.adaptableStateKey) !== null && _a !== void 0 ? _a : returnedAdaptableOptions.adaptableId;
     returnedAdaptableOptions.adaptableQLOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions, adaptableOptions.adaptableQLOptions);
     returnedAdaptableOptions.columnOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.columnOptions, adaptableOptions.columnOptions);
     returnedAdaptableOptions.adaptableQLOptions.expressionOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions.expressionOptions, returnedAdaptableOptions.adaptableQLOptions.expressionOptions);
@@ -21,13 +22,13 @@ function assignAdaptableOptions(adaptableOptions) {
     returnedAdaptableOptions.entitlementOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.entitlementOptions, adaptableOptions.entitlementOptions);
     returnedAdaptableOptions.dashboardOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dashboardOptions, adaptableOptions.dashboardOptions);
     returnedAdaptableOptions.editOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.editOptions, adaptableOptions.editOptions);
-    returnedAdaptableOptions.editOptions.rowFormOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.editOptions.rowFormOptions, returnedAdaptableOptions.editOptions.rowFormOptions);
+    returnedAdaptableOptions.actionOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionOptions, adaptableOptions.actionOptions);
+    returnedAdaptableOptions.actionOptions.actionRowFormOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionOptions.actionRowFormOptions, returnedAdaptableOptions.actionOptions.actionRowFormOptions);
     returnedAdaptableOptions.containerOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.containerOptions, adaptableOptions.containerOptions);
     returnedAdaptableOptions.generalOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.generalOptions, adaptableOptions.generalOptions);
     returnedAdaptableOptions.searchOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.searchOptions, adaptableOptions.searchOptions);
     returnedAdaptableOptions.filterOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.filterOptions, adaptableOptions.filterOptions);
     returnedAdaptableOptions.userInterfaceOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.userInterfaceOptions, adaptableOptions.userInterfaceOptions);
-    returnedAdaptableOptions.userInterfaceOptions.actionOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.userInterfaceOptions.actionOptions, returnedAdaptableOptions.userInterfaceOptions.actionOptions);
     returnedAdaptableOptions.userInterfaceOptions.dateInputOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.userInterfaceOptions.dateInputOptions, returnedAdaptableOptions.userInterfaceOptions.dateInputOptions);
     returnedAdaptableOptions.menuOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.menuOptions, adaptableOptions.menuOptions);
     returnedAdaptableOptions.stateOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.stateOptions, adaptableOptions.stateOptions);
@@ -97,16 +98,6 @@ function getAppropriateAccessLevel(adaptableObject, moduleAccessLevel) {
     return moduleAccessLevel;
 }
 exports.getAppropriateAccessLevel = getAppropriateAccessLevel;
-// perform any checks that are necessary here
-// for now just adaptableId
-function checkAdaptableOptions(adaptableOptions) {
-    if (adaptableOptions.adaptableId) {
-        if (adaptableOptions.adaptableId.includes('.')) {
-            LoggingHelper_1.ConsoleLogWarning("The 'adaptableId' property in adaptableOptions should not include a '.'.  We strongly recommend that you remove this.");
-        }
-    }
-}
-exports.checkAdaptableOptions = checkAdaptableOptions;
 function runAdaptableComparerFunction(columnId, columnValues, adaptable) {
     return function compareItemsOfCustomSort(valueA, valueB, nodeA, nodeB) {
         let firstElementValueString = nodeA
@@ -148,11 +139,10 @@ function addAdaptableObjectUuidAndSource(adaptableObject) {
 }
 exports.addAdaptableObjectUuidAndSource = addAdaptableObjectUuidAndSource;
 exports.AdaptableHelper = {
-    assignadaptableOptions: assignAdaptableOptions,
+    assignAdaptableOptions,
     initPredefinedConfigWithUuids,
     checkValidPrimaryKey,
     AdaptableObjectExistsInState,
-    checkAdaptableOptions,
     runAdaptableComparerFunction,
     getAppropriateAccessLevel,
     addUuidAndSource: addAdaptableObjectUuidAndSource,

package/src/Utilities/Helpers/DateHelper.d.ts

@@ -8,3 +8,30 @@ export declare const isValueValidDate: (data: any) => boolean;
 export declare const dateToISO: (date: Date | number | string) => string;
 export declare const parseToISO: (date: string | Date | number, dateFormat?: string) => string;
 export declare const parseDateValue: (dateValue: string | Date | number, dateFormat?: string) => Date | undefined;
+/**
+ * Creates a date with the same day/month/year/hour with the current timezone.
+ * '2022-06-01T17:00:00.000Z' => '2022-06-01T17:00:00.000+03:00' // RO time
+ *
+ * new Date() always creates the date using the current timezone.
+ * To compare two dates, they need to be in the same timezone.
+ *
+ * @param date Date
+ */
+export declare const utcDateToSameDateInLocale: (date: Date) => Date;
+/**
+ * To make sure selected/input date is correct and in the current time-zone.
+ 
+ *
+ * '2022-06-14' is considered to be '2022-06-13 00:00:00.
+ * And when date object is created it uses the current timezone.
+ *
+ * '2022-06-14' => Mon Jun 13 2022 20:00:00 GMT-0400 (Eastern Daylight Time)
+ *
+ * @param stringDate date string
+ */
+export declare const parseFilterInputDate: (stringDate: string) => Date;
+/**
+ * Used to parse the date from rowDate inside date predicates.
+ * The date is parsed in moved to local timezone.
+ */
+export declare const parseFilterValueDate: (value: any) => Date;

package/src/Utilities/Helpers/DateHelper.js

@@ -1,34 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseDateValue = exports.parseToISO = exports.dateToISO = exports.isValueValidDate = exports.isValidDate = void 0;
+exports.parseFilterValueDate = exports.parseFilterInputDate = exports.utcDateToSameDateInLocale = exports.parseDateValue = exports.parseToISO = exports.dateToISO = exports.isValueValidDate = exports.isValidDate = void 0;
 const tslib_1 = require("tslib");
 const parseISO_1 = tslib_1.__importDefault(require("date-fns/parseISO"));
 const parse_1 = tslib_1.__importDefault(require("date-fns/parse"));
 const LoggingHelper_1 = require("./LoggingHelper");
 const FormatHelper_1 = require("./FormatHelper");
-exports.isValidDate = (date) => {
+const isValidDate = (date) => {
     return date instanceof Date && !isNaN(date.getTime());
 };
+exports.isValidDate = isValidDate;
 /**
  * Checks if the data contains a value that represents a valid date.
  *
  * @param data any kind of data
  */
-exports.isValueValidDate = (data) => {
+const isValueValidDate = (data) => {
     if (!data || typeof data === 'boolean') {
         return false;
     }
     const date = new Date(data);
     return !isNaN(date.getTime());
 };
-exports.dateToISO = (date) => {
+exports.isValueValidDate = isValueValidDate;
+const dateToISO = (date) => {
     return FormatHelper_1.DateFormatter(date, { Pattern: 'yyyy-MM-dd' });
 };
-exports.parseToISO = (date, dateFormat) => {
+exports.dateToISO = dateToISO;
+const parseToISO = (date, dateFormat) => {
     const dateInstance = exports.parseDateValue(date, dateFormat);
     return exports.isValidDate(dateInstance) ? exports.dateToISO(dateInstance) : '';
 };
-exports.parseDateValue = (dateValue, dateFormat) => {
+exports.parseToISO = parseToISO;
+const parseDateValue = (dateValue, dateFormat) => {
     if (dateValue == undefined) {
         return undefined;
     }
@@ -58,3 +62,36 @@ exports.parseDateValue = (dateValue, dateFormat) => {
     }
     return dateInstance;
 };
+exports.parseDateValue = parseDateValue;
+/**
+ * Creates a date with the same day/month/year/hour with the current timezone.
+ * '2022-06-01T17:00:00.000Z' => '2022-06-01T17:00:00.000+03:00' // RO time
+ *
+ * new Date() always creates the date using the current timezone.
+ * To compare two dates, they need to be in the same timezone.
+ *
+ * @param date Date
+ */
+const utcDateToSameDateInLocale = (date) => {
+    return new Date(date.getTime() + date.getTimezoneOffset() * 60 * 1000);
+};
+exports.utcDateToSameDateInLocale = utcDateToSameDateInLocale;
+/**
+ * To make sure selected/input date is correct and in the current time-zone.
+ 
+ *
+ * '2022-06-14' is considered to be '2022-06-13 00:00:00.
+ * And when date object is created it uses the current timezone.
+ *
+ * '2022-06-14' => Mon Jun 13 2022 20:00:00 GMT-0400 (Eastern Daylight Time)
+ *
+ * @param stringDate date string
+ */
+const parseFilterInputDate = (stringDate) => exports.utcDateToSameDateInLocale(new Date(stringDate));
+exports.parseFilterInputDate = parseFilterInputDate;
+/**
+ * Used to parse the date from rowDate inside date predicates.
+ * The date is parsed in moved to local timezone.
+ */
+const parseFilterValueDate = (value) => exports.utcDateToSameDateInLocale(exports.parseDateValue(value));
+exports.parseFilterValueDate = parseFilterValueDate;

package/src/Utilities/Helpers/Helper.js

@@ -22,7 +22,7 @@ function cloneObject(obj) {
     return JSON.parse(JSON.stringify(obj));
 }
 exports.cloneObject = cloneObject;
-exports.arrayToKeyMap = (arr) => {
+const arrayToKeyMap = (arr) => {
     const defaultAccumulator = {};
     if (!arr || !Array.isArray(arr)) {
         return defaultAccumulator;
@@ -32,6 +32,7 @@ exports.arrayToKeyMap = (arr) => {
         return acc;
     }, defaultAccumulator);
 };
+exports.arrayToKeyMap = arrayToKeyMap;
 // converts an array (or an array of arrays) to CSV
 function convertArrayToCsv(array, separator = " ' ") {
     let csvContent = '';

package/src/Utilities/Helpers/LoggingHelper.js

@@ -22,7 +22,7 @@ function ConsoleLogByMessageType(message, messageType, ...optionalParams) {
     }
 }
 exports.ConsoleLogByMessageType = ConsoleLogByMessageType;
-exports.getLoggingFunctions = (channel) => {
+const getLoggingFunctions = (channel) => {
     const prefix = channel ? `${channel}:` : '';
     const info = exports.log.extend(`${prefix}info`);
     info.log = console.info.bind(console);
@@ -71,6 +71,7 @@ exports.getLoggingFunctions = (channel) => {
         LogAdaptableInfo,
     };
 };
+exports.getLoggingFunctions = getLoggingFunctions;
 function ConsoleLogWarning(message, ...optionalParams) {
     if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(optionalParams)) {
         console.warn(message, optionalParams);

package/src/Utilities/Helpers/StyleHelper.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVariableColor = exports.toStyle = exports.convertCSSAbsoluteFontSizeToPt = exports.convertAdaptableStyleToCSS = void 0;
 const EnumExtensions_1 = require("../Extensions/EnumExtensions");
-exports.convertAdaptableStyleToCSS = (style) => {
+const convertAdaptableStyleToCSS = (style) => {
     let result = {};
     if (style.BackColor !== undefined && style.BackColor !== null) {
         result.backgroundColor = style.BackColor;
@@ -25,8 +25,9 @@ exports.convertAdaptableStyleToCSS = (style) => {
     // assertion added to comply with the ag-Grid types
     return result;
 };
+exports.convertAdaptableStyleToCSS = convertAdaptableStyleToCSS;
 // based on http://jerekdain.com/fontconversion.html
-exports.convertCSSAbsoluteFontSizeToPt = (fontSize) => {
+const convertCSSAbsoluteFontSizeToPt = (fontSize) => {
     switch (fontSize) {
         case 'x-large':
             return 18;
@@ -42,10 +43,12 @@ exports.convertCSSAbsoluteFontSizeToPt = (fontSize) => {
             return 12;
     }
 };
-exports.toStyle = (style) => {
+exports.convertCSSAbsoluteFontSizeToPt = convertCSSAbsoluteFontSizeToPt;
+const toStyle = (style) => {
     return Object.assign(Object.assign({}, exports.convertAdaptableStyleToCSS(style !== null && style !== void 0 ? style : {})), { borderWidth: (style === null || style === void 0 ? void 0 : style.BorderColor) ? 2 : 0, borderStyle: 'solid' });
 };
-exports.getVariableColor = (variable) => {
+exports.toStyle = toStyle;
+const getVariableColor = (variable) => {
     var _a;
     const isVariable = (_a = variable === null || variable === void 0 ? void 0 : variable.startsWith) === null || _a === void 0 ? void 0 : _a.call(variable, 'var(');
     if (!isVariable) {
@@ -57,3 +60,4 @@ exports.getVariableColor = (variable) => {
     }
     return getComputedStyle(document.documentElement).getPropertyValue(match[1]).trim();
 };
+exports.getVariableColor = getVariableColor;

package/src/Utilities/MenuItem.d.ts

@@ -2,13 +2,14 @@ import * as Redux from 'redux';
 import { ModuleParams } from '../View/Components/SharedProps/ModuleViewPopupProps';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
 import { AdaptableModule } from '../PredefinedConfig/Common/Types';
+import { AdaptableIcon } from '../PredefinedConfig/Common/AdaptableIcon';
 export declare class MenuItemDoReduxAction implements AdaptableMenuItem {
     constructor(label: string, module: AdaptableModule, reduxAction: Redux.Action, icon: string, isVisible: boolean);
     reduxAction: Redux.Action;
     label: string;
     module: AdaptableModule;
     isVisible: boolean;
-    icon: string;
+    icon: AdaptableIcon;
 }
 export declare class MenuItemDoClickFunction implements AdaptableMenuItem {
     constructor(label: string, module: AdaptableModule, clickFunction: () => void, icon: string, isVisible: boolean);
@@ -16,7 +17,7 @@ export declare class MenuItemDoClickFunction implements AdaptableMenuItem {
     label: string;
     module: AdaptableModule;
     isVisible: boolean;
-    icon: string;
+    icon: AdaptableIcon;
 }
 export declare class MenuItemShowPopup implements AdaptableMenuItem {
     constructor(label: string, module: AdaptableModule, componentName: string, icon: string, isVisible: boolean, popupParams?: ModuleParams);
@@ -24,5 +25,5 @@ export declare class MenuItemShowPopup implements AdaptableMenuItem {
     label: string;
     module: AdaptableModule;
     isVisible: boolean;
-    icon: string;
+    icon: AdaptableIcon;
 }

package/src/Utilities/MenuItem.js

@@ -9,7 +9,9 @@ class MenuItemDoReduxAction {
         this.label = label;
         this.module = module;
         this.isVisible = isVisible;
-        this.icon = icon;
+        this.icon = {
+            name: icon,
+        };
         this.reduxAction = reduxAction;
     }
 }
@@ -19,7 +21,9 @@ class MenuItemDoClickFunction {
         this.label = label;
         this.module = module;
         this.isVisible = isVisible;
-        this.icon = icon;
+        this.icon = {
+            name: icon,
+        };
         this.onClick = clickFunction;
     }
 }
@@ -30,7 +34,9 @@ class MenuItemShowPopup {
         this.label = label;
         this.module = module;
         this.isVisible = isVisible;
-        this.icon = icon;
+        this.icon = {
+            name: icon,
+        };
         this.reduxAction = PopupRedux.PopupShowScreen(module, componentName, popupParams);
     }
 }

package/src/Utilities/ObjectFactory.js

@@ -375,6 +375,7 @@ function CreateToastOptions(notificationsOptions, { onClose, containerId }) {
         transition: transition,
         draggablePercent: 75,
         onClose,
+        // progress: undefined,
     };
     return toastProps;
 }

package/src/Utilities/Services/Interface/IMetamodelService.d.ts

@@ -11,4 +11,5 @@ export interface GridInfoOption {
 }
 export interface IMetamodelService extends IAdaptableService {
     getGridInfoOptions(): GridInfoOptions;
+    validateAdaptableOptionsValues(): void;
 }

package/src/Utilities/Services/Interface/IRowEditService.d.ts

@@ -1,8 +1,8 @@
 import { RowNode } from '@ag-grid-community/all-modules';
 import { IAdaptableService } from './IAdaptableService';
 import { AdaptableForm } from '../../../PredefinedConfig/Common/AdaptableForm';
-import { CreateRowFormContext, EditRowFormContext } from '../../../AdaptableOptions/EditOptions';
+import { CreateActionRowContext, EditActionRowContext } from '../../../AdaptableOptions/ActionOptions';
 export interface IRowEditService extends IAdaptableService {
-    buildRowEditForm(rowNode: RowNode): AdaptableForm<EditRowFormContext>;
-    buildRowCreateForm(clonedRowNode?: RowNode): AdaptableForm<CreateRowFormContext>;
+    buildRowEditForm(rowNode: RowNode): AdaptableForm<EditActionRowContext>;
+    buildRowCreateForm(clonedRowNode?: RowNode): AdaptableForm<CreateActionRowContext>;
 }

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

@@ -5,7 +5,13 @@ export declare class MetamodelService implements IMetamodelService {
     private gridInfoOptions;
     constructor(adaptableApi: AdaptableApi);
     getGridInfoOptions(): GridInfoOptions;
+    validateAdaptableOptionsValues(): void;
+    private validateOptionsObject;
+    private getExpectedOptionsValueType;
     private buildGridInfoOptions;
     private mapGridInfoContainerItems;
-    destroy(): void;
+    private getAdaptableOptionsDefaultValues;
+    private getAdaptableMetamodel;
+    private getAdaptableOptionsMetamodel;
+    private getAdaptableOptions;
 }

package/src/Utilities/Services/MetamodelService.js

@@ -3,6 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetamodelService = void 0;
 const adaptable_metamodel_1 = require("../../metamodel/adaptable.metamodel");
 const DefaultAdaptableOptions_1 = require("../Defaults/DefaultAdaptableOptions");
+const LoggingHelper_1 = require("../Helpers/LoggingHelper");
+const DocumentationLinkConstants_1 = require("../Constants/DocumentationLinkConstants");
+const supportedMetamodelTypes = [
+    'string',
+    'number',
+    'boolean',
+    'array',
+    'function',
+    'REFERENCE',
+];
 class MetamodelService {
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
@@ -13,17 +23,72 @@ class MetamodelService {
     getGridInfoOptions() {
         return this.gridInfoOptions;
     }
+    validateAdaptableOptionsValues() {
+        var _a;
+        LoggingHelper_1.LogAdaptableInfo('Validating Adaptable Options...');
+        const adaptableOptionsValues = this.getAdaptableOptions();
+        const adaptableOptionsMetamodel = this.getAdaptableOptionsMetamodel();
+        const adaptableOptionsDefaultValues = this.getAdaptableOptionsDefaultValues();
+        if ((_a = adaptableOptionsValues.adaptableId) === null || _a === void 0 ? void 0 : _a.includes('.')) {
+            LoggingHelper_1.ConsoleLogWarning("The 'AdaptableOptions.adaptableId' property should NOT include a '.' character.  We strongly recommend to remove it to avoid unexpected AdapTable behavior.");
+        }
+        const validationErrors = [];
+        this.validateOptionsObject(validationErrors, 'AdaptableOptions', adaptableOptionsValues, adaptableOptionsMetamodel, adaptableOptionsDefaultValues);
+        if (validationErrors.length) {
+            LoggingHelper_1.LogAdaptableWarning([
+                'AdaptableOptions validation errors:',
+                '\n',
+                ...validationErrors,
+                '\n',
+                `See AdaptableOptions documentation at ${DocumentationLinkConstants_1.AdaptableOptionsDocsLink} for details`,
+            ].join('\n'));
+        }
+    }
+    validateOptionsObject(validationErrors, optionsObjectName, optionsObject, optionsObjectMetamodel, optionsObjectDefaultValues) {
+        Object.entries(optionsObject).forEach(([optionKey, optionValue]) => {
+            const optionMetamodel = optionsObjectMetamodel.properties.find((metamodelProperty) => metamodelProperty.name === optionKey);
+            if (!optionMetamodel) {
+                validationErrors.push(`${optionsObjectName}.${optionKey} (value=${optionValue}) :: unknown/unsupported property, will be ignored`);
+                return;
+            }
+            // let's try to validate the type of the provided value
+            const expectedOptionsValueType = this.getExpectedOptionsValueType(optionMetamodel);
+            const providedOptionsValueType = Array.isArray(optionValue) ? 'array' : typeof optionValue;
+            if (!expectedOptionsValueType) {
+                return;
+            }
+            // if it's a REFERENCE, we try to go (recursively) deeper
+            if (expectedOptionsValueType === 'REFERENCE') {
+                const referenceObjectName = optionMetamodel.reference;
+                const referenceObject = optionsObject[optionKey];
+                const referenceObjectMetamodel = this.getAdaptableMetamodel()[referenceObjectName];
+                if (referenceObject && (referenceObjectMetamodel === null || referenceObjectMetamodel === void 0 ? void 0 : referenceObjectMetamodel.kind) === 'Interface') {
+                    this.validateOptionsObject(validationErrors, referenceObjectName, referenceObject, referenceObjectMetamodel, optionsObjectDefaultValues === null || optionsObjectDefaultValues === void 0 ? void 0 : optionsObjectDefaultValues[optionKey]);
+                }
+            }
+            else if (supportedMetamodelTypes.includes(providedOptionsValueType) &&
+                providedOptionsValueType !== expectedOptionsValueType) {
+                validationErrors.push(`${optionsObjectName}.${optionKey} (value=${optionValue}) :: wrong type (${providedOptionsValueType}), expected ${expectedOptionsValueType}`);
+            }
+        });
+    }
+    getExpectedOptionsValueType(metamodelProperty) {
+        const metamodelPropertyKind = metamodelProperty.kind;
+        if (supportedMetamodelTypes.includes(metamodelPropertyKind)) {
+            return metamodelPropertyKind;
+        }
+    }
     buildGridInfoOptions() {
         const gridInfoOptions = new Map();
-        const adaptableMetamodel = adaptable_metamodel_1.ADAPTABLE_METAMODEL;
-        const adaptableOptionsMetamodel = adaptableMetamodel['AdaptableOptions'];
-        const adaptableOptionsValues = this.adaptableApi.internalApi.getAdaptableOptions();
-        const adaptableOptionsDefaultValues = DefaultAdaptableOptions_1.DefaultAdaptableOptions;
+        const adaptableMetamodel = this.getAdaptableMetamodel();
+        const adaptableOptionsMetamodel = this.getAdaptableOptionsMetamodel();
+        const adaptableOptionsValues = this.getAdaptableOptions();
+        const adaptableOptionsDefaultValues = this.getAdaptableOptionsDefaultValues();
         if (!adaptableOptionsMetamodel) {
             // should never happen
             return gridInfoOptions;
         }
-        // root-level properties are grouped in a syntethic 'Base Options' container
+        // root-level properties are grouped in a synthetic 'Base Options' container
         const baseOptionsItems = this.mapGridInfoContainerItems(adaptableOptionsMetamodel, adaptableOptionsValues, adaptableOptionsDefaultValues);
         gridInfoOptions.set('baseOptions', {
             containerLabel: 'Base Options',
@@ -65,6 +130,17 @@ class MetamodelService {
             };
         });
     }
-    destroy() { }
+    getAdaptableOptionsDefaultValues() {
+        return DefaultAdaptableOptions_1.DefaultAdaptableOptions;
+    }
+    getAdaptableMetamodel() {
+        return adaptable_metamodel_1.ADAPTABLE_METAMODEL;
+    }
+    getAdaptableOptionsMetamodel() {
+        return this.getAdaptableMetamodel()['AdaptableOptions'];
+    }
+    getAdaptableOptions() {
+        return this.adaptableApi.internalApi.getAdaptableOptions();
+    }
 }
 exports.MetamodelService = MetamodelService;

package/src/Utilities/Services/ModuleService.js

@@ -94,7 +94,7 @@ class ModuleService {
             case 'Dashboard':
                 return learnUrl + 'ui-dashboard';
             case 'DataSet':
-                return learnUrl + 'handbook-data-sources';
+                return learnUrl + 'handbook-data-sets';
             case 'DataChangeHistory':
                 return learnUrl + 'handbook-monitoring#data-change-history';
             case 'Export':
@@ -125,6 +125,8 @@ class ModuleService {
                 return learnUrl + 'handbook-editing#smart-edit';
             case 'StateManagement':
                 return learnUrl + 'dev-guide-adaptable-state';
+            case 'StatusBar':
+                return learnUrl + 'ui-status-bar';
             case 'SystemStatus':
                 return learnUrl + 'handbook-notifying';
             case 'TeamSharing':