@adaptabletools/adaptable 11.0.0-canary.2 → 11.0.0-canary.6

package/src/Utilities/ExpressionFunctions/deepMap.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepMap = void 0;
+const SORT_ASC_REVISION = (p1, p2) => sortAscending(p1.revision, p2.revision);
+class DeepMap {
+    constructor(initial) {
+        this.map = new Map();
+        this.length = 0;
+        this.revision = 0;
+        this.visit = (fn) => {
+            this.map.forEach((_, k) => this.visitKey(k, this.map, [], fn));
+        };
+        this.visitDepthFirst = (fn) => {
+            this.visitWithNext([], fn);
+        };
+        this.visitWithNext = (parentKeys, fn, currentMap = this.map) => {
+            if (!currentMap) {
+                return;
+            }
+            let i = 0;
+            currentMap.forEach((_, key) => {
+                const pair = currentMap.get(key);
+                if (!pair) {
+                    return;
+                }
+                const { map } = pair;
+                const keys = [...parentKeys, key];
+                const next = map ? () => this.visitWithNext(keys, fn, map) : undefined;
+                if (pair.hasOwnProperty('value')) {
+                    fn(pair.value, keys, i, next);
+                    i++;
+                }
+                else {
+                    next === null || next === void 0 ? void 0 : next();
+                }
+            });
+        };
+        if (initial) {
+            initial.forEach((entry) => {
+                const [keys, value] = entry;
+                this.set(keys, value);
+            });
+        }
+    }
+    static clone(map) {
+        const clone = new DeepMap();
+        map.visit((pair, keys) => {
+            clone.set(keys, pair.value);
+        });
+        return clone;
+    }
+    set(keys, value) {
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot set given keys - please provide a non-empty keys array.`;
+            // currentMap.set((EMPTY_KEY as unknown) as K, { value });
+            // this.length++;
+            // return this;
+        }
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                const pair = currentMap.has(key) ? currentMap.get(key) : {};
+                pair.revision = this.revision++;
+                pair.value = value;
+                currentMap.set(key, pair);
+                this.length++;
+            }
+            else {
+                const pair = currentMap.has(key) ? currentMap.get(key) : {};
+                if (!pair.map) {
+                    pair.map = new Map();
+                    currentMap.set(key, pair);
+                }
+                currentMap = pair.map;
+            }
+        }
+        return this;
+    }
+    get(keys) {
+        var _a;
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot get given keys - please provide a non-empty keys array.`;
+            // return currentMap.get((EMPTY_KEY as unknown) as K)?.value;
+        }
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                return (_a = currentMap.get(key)) === null || _a === void 0 ? void 0 : _a.value;
+            }
+            else {
+                const pair = currentMap.get(key);
+                if (!pair || !pair.map) {
+                    return;
+                }
+                currentMap = pair.map;
+            }
+        }
+        return;
+    }
+    get size() {
+        return this.length;
+    }
+    clear() {
+        const clearMap = (map) => {
+            map.forEach((value, _key) => {
+                const { map } = value;
+                if (map) {
+                    clearMap(map);
+                }
+            });
+            map.clear();
+        };
+        clearMap(this.map);
+        this.length = 0;
+        this.revision = 0;
+    }
+    delete(keys) {
+        keys = [...keys];
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot delete given keys - please provide a non-empty keys array.`;
+            // if (currentMap.has(EMPTY_KEY as unknown as K)) {
+            //   this.length--;
+            // }
+            // return currentMap.delete((EMPTY_KEY as unknown) as K);
+        }
+        let maps = [currentMap];
+        let result = false;
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                const pair = currentMap.get(key);
+                if (pair) {
+                    if (pair.hasOwnProperty('value')) {
+                        delete pair.value;
+                        delete pair.revision;
+                        result = true;
+                        this.length--;
+                    }
+                    if (pair.map && pair.map.size === 0) {
+                        delete pair.map;
+                    }
+                    if (!pair.map) {
+                        // pair is empty, so we can remove it altogether
+                        currentMap.delete(key);
+                    }
+                }
+                break;
+            }
+            else {
+                const pair = currentMap.get(key);
+                if (!pair || !pair.map) {
+                    result = false;
+                    break;
+                }
+                currentMap = pair.map;
+                maps.push(currentMap);
+            }
+        }
+        while (maps.length) {
+            let map = maps.pop();
+            let key = keys.pop();
+            if (key && (map === null || map === void 0 ? void 0 : map.size) === 0) {
+                let parentMap = maps[maps.length - 1];
+                let pair = parentMap === null || parentMap === void 0 ? void 0 : parentMap.get(key);
+                if (pair) {
+                    // pair.map === map ; which can be deleted
+                    delete pair.map;
+                    if (!pair.hasOwnProperty('value')) {
+                        // whole pair can be successfully deleted from parentMap
+                        parentMap.delete(key);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    has(keys) {
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot find existing given keys - please provide a non-empty keys array.`;
+            // return (
+            //   currentMap.has((EMPTY_KEY as unknown) as K) &&
+            //   currentMap.get((EMPTY_KEY as unknown) as K)?.value !== undefined
+            // );
+        }
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                const pair = currentMap.get(key);
+                return !!pair && pair.hasOwnProperty('value');
+            }
+            else {
+                const pair = currentMap.get(key);
+                if (!pair || !pair.map) {
+                    return false;
+                }
+                currentMap = pair.map;
+            }
+        }
+        return false;
+    }
+    visitKey(key, currentMap, parentKeys, fn) {
+        const pair = currentMap.get(key);
+        if (!pair) {
+            return;
+        }
+        const { map } = pair;
+        const keys = [...parentKeys, key];
+        const next = once(() => {
+            if (map) {
+                map.forEach((_, k) => {
+                    this.visitKey(k, map, keys, fn);
+                });
+            }
+        });
+        if (pair.hasOwnProperty('value')) {
+            fn(pair, keys, next);
+        }
+        // if it was called by fn, it won't be called again, as it's once-d
+        next();
+    }
+    getArray(fn) {
+        const result = [];
+        this.visit((pair, keys) => {
+            result.push(fn(Object.assign(Object.assign({}, pair), { keys })));
+        });
+        return result;
+    }
+    values() {
+        return this.sortedIterator((pair) => pair.value);
+    }
+    keys() {
+        const keys = this.sortedIterator((pair) => pair.keys);
+        return keys;
+    }
+    entries() {
+        return this.sortedIterator((pair) => [pair.keys, pair.value]);
+    }
+    topDownEntries() {
+        return this.getArray((pair) => [pair.keys, pair.value]);
+    }
+    topDownKeys() {
+        return this.getArray((pair) => pair.keys);
+    }
+    topDownValues() {
+        return this.getArray((pair) => pair.value);
+    }
+    sortedIterator(fn) {
+        const result = [];
+        this.visit((pair, keys) => {
+            result.push(Object.assign(Object.assign({}, pair), { keys }));
+        });
+        result.sort(SORT_ASC_REVISION);
+        function* makeIterator() {
+            for (let i = 0, len = result.length; i < len; i++) {
+                yield fn(result[i]);
+            }
+        }
+        return makeIterator();
+    }
+}
+exports.DeepMap = DeepMap;
+function once(fn) {
+    let called = false;
+    let result = null;
+    const onceFn = () => {
+        if (called) {
+            return result;
+        }
+        called = true;
+        result = fn();
+        return result;
+    };
+    return onceFn;
+}
+const sortAscending = (a, b) => a - b;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -5,7 +5,7 @@ const tslib_1 = require("tslib");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
 const operators_1 = require("rxjs/operators");
-const toNumber_1 = tslib_1.__importDefault(require("lodash-es/toNumber"));
+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

package/src/Utilities/ExpressionFunctions/groupingMap.d.ts

@@ -0,0 +1,36 @@
+import { DeepMap } from './deepMap';
+export declare type GroupKeyType<T extends any = any> = T;
+export declare type GroupBy<DataType, KeyType> = {
+    field: keyof DataType;
+    toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
+    column?: string;
+};
+export declare type GroupParams<DataType, KeyType> = {
+    groupBy: GroupBy<DataType, KeyType>[];
+    defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
+    reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
+};
+export declare type DataSourceAggregationReducer<T, AggregationResultType> = {
+    name?: string;
+    field?: keyof T;
+    initialValue?: AggregationResultType;
+    getter?: (data: T) => any;
+    reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
+    done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
+};
+export declare type DataGroupResult<DataType, KeyType extends any> = {
+    deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
+    groupParams: GroupParams<DataType, KeyType>;
+    initialData: DataType[];
+    reducerResults?: Record<string, AggregationReducerResult>;
+};
+export declare type DeepMapGroupValueType<DataType, KeyType> = {
+    items: DataType[];
+    commonData?: Partial<DataType>;
+    reducerResults: Record<string, AggregationReducerResult>;
+};
+export declare type AggregationReducerResult<AggregationResultType extends any = any> = {
+    value: AggregationResultType;
+    id: string;
+};
+export declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;

package/src/Utilities/ExpressionFunctions/groupingMap.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.group = void 0;
+const deepMap_1 = require("./deepMap");
+function DEFAULT_TO_KEY(value) {
+    return value;
+}
+function group(groupParams, data) {
+    const { groupBy, defaultToKey = DEFAULT_TO_KEY, reducers } = groupParams;
+    const groupByLength = groupBy.length;
+    const deepMap = new deepMap_1.DeepMap();
+    let currentGroupKeys = [];
+    const initialReducerValue = initReducers(reducers);
+    const globalReducerResults = Object.assign({}, initialReducerValue);
+    for (let i = 0, len = data.length; i < len; i++) {
+        let item = data[i];
+        for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
+            const { field: groupByProperty, toKey: groupToKey } = groupBy[groupByIndex];
+            const key = (groupToKey || defaultToKey)(item[groupByProperty], item);
+            currentGroupKeys.push(key);
+            if (!deepMap.has(currentGroupKeys)) {
+                const deepMapGroupValue = {
+                    items: [],
+                    reducerResults: Object.assign({}, initialReducerValue),
+                };
+                deepMap.set(currentGroupKeys, deepMapGroupValue);
+            }
+            const { items: currentGroupItems, reducerResults } = deepMap.get(currentGroupKeys);
+            currentGroupItems.push(item);
+            if (reducers) {
+                computeReducersFor(item, reducers, reducerResults);
+            }
+        }
+        if (reducers) {
+            computeReducersFor(item, reducers, globalReducerResults);
+        }
+        currentGroupKeys.length = 0;
+    }
+    if (reducers) {
+        deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
+            completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
+            next === null || next === void 0 ? void 0 : next();
+        });
+    }
+    if (reducers) {
+        completeReducers(reducers, globalReducerResults, data);
+    }
+    const result = {
+        deepMap,
+        groupParams,
+        initialData: data,
+        reducerResults: globalReducerResults,
+    };
+    return result;
+}
+exports.group = group;
+function initReducers(reducers) {
+    if (!reducers || !Object.keys(reducers).length) {
+        return {};
+    }
+    const result = {};
+    for (let key in reducers)
+        if (reducers.hasOwnProperty(key)) {
+            result[key] = reducers[key].initialValue;
+        }
+    return result;
+}
+/**
+ *
+ * This fn mutates the reducerResults array!!!
+ *
+ * @param data data item
+ * @param reducers an array of reducers
+ * @param reducerResults the results on which to operate
+ *
+ */
+function computeReducersFor(data, reducers, reducerResults) {
+    var _a, _b;
+    if (!reducers || !Object.keys(reducers).length) {
+        return;
+    }
+    for (let key in reducers)
+        if (reducers.hasOwnProperty(key)) {
+            const reducer = reducers[key];
+            if (typeof reducer.reducer !== 'function') {
+                continue;
+            }
+            const currentValue = reducerResults[key];
+            const value = reducer.field ? data[reducer.field] : (_b = (_a = reducer.getter) === null || _a === void 0 ? void 0 : _a.call(reducer, data)) !== null && _b !== void 0 ? _b : null;
+            reducerResults[key] = reducer.reducer(currentValue, value, data);
+        }
+}
+function completeReducers(reducers, reducerResults, items) {
+    if (reducers) {
+        for (let key in reducers)
+            if (reducers.hasOwnProperty(key)) {
+                const reducer = reducers[key];
+                if (reducer.done) {
+                    reducerResults[key] = reducer.done(reducerResults[key], items);
+                }
+            }
+    }
+    return reducerResults;
+}

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -4,7 +4,7 @@ exports.observableExpressionFunctions = void 0;
 const tslib_1 = require("tslib");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
-const parseInt_1 = tslib_1.__importDefault(require("lodash-es/parseInt"));
+const parseInt_1 = tslib_1.__importDefault(require("lodash/parseInt"));
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 // numeric value(digits) followed by a single 's', 'm' or 'h' letter (case insensitive)
@@ -417,8 +417,7 @@ const getSlidingTimeframe$ = (source$, timeframeDuration, onTimeframeEnter, onTi
     }));
 };
 const getMaxTimeframeSize = (expressionValue, context) => {
-    let maxTimeframeSize = context.api.internalApi.getAdaptableOptions().queryLanguageOptions
-        .maxTimeframeSize;
+    let maxTimeframeSize = context.api.internalApi.getAdaptableOptions().queryLanguageOptions.maxTimeframeSize;
     if (maxTimeframeSize > SYSTEM_MAX_TIMEFRAME_SIZE) {
         maxTimeframeSize = SYSTEM_MAX_TIMEFRAME_SIZE;
     }

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -17,6 +17,7 @@ const differenceInWeeks_1 = tslib_1.__importDefault(require("date-fns/difference
 const differenceInMonths_1 = tslib_1.__importDefault(require("date-fns/differenceInMonths"));
 const differenceInYears_1 = tslib_1.__importDefault(require("date-fns/differenceInYears"));
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+const dateUtils_1 = require("./dateUtils");
 exports.scalarExpressionFunctions = {
     ADD: {
         handler(args) {
@@ -222,7 +223,9 @@ exports.scalarExpressionFunctions = {
     },
     DIFF_DAYS: {
         handler(args) {
-            return differenceInDays_1.default(args[0], args[1]);
+            const [first, second] = dateUtils_1.normalizeDateParams(args);
+            const result = differenceInDays_1.default(first, second);
+            return isNaN(result) ? '' : result;
         },
         description: 'Returns the difference in days between 2 dates',
         signatures: ['DIFF_DAYS(a: date, b: date)'],
@@ -230,7 +233,9 @@ exports.scalarExpressionFunctions = {
     },
     DIFF_WEEKS: {
         handler(args) {
-            return differenceInWeeks_1.default(args[0], args[1]);
+            const [first, second] = dateUtils_1.normalizeDateParams(args);
+            const result = differenceInWeeks_1.default(first, second);
+            return isNaN(result) ? '' : result;
         },
         description: 'Returns the difference in weeks between 2 dates',
         signatures: ['DIFF_WEEKS(a: date, b: date)'],
@@ -238,7 +243,9 @@ exports.scalarExpressionFunctions = {
     },
     DIFF_MONTHS: {
         handler(args) {
-            return differenceInMonths_1.default(args[0], args[1]);
+            const [first, second] = dateUtils_1.normalizeDateParams(args);
+            const result = differenceInMonths_1.default(first, second);
+            return isNaN(result) ? '' : result;
         },
         description: 'Returns the difference in months between 2 dates',
         signatures: ['DIFF_MONTHS(a: date, b: date)'],
@@ -246,7 +253,9 @@ exports.scalarExpressionFunctions = {
     },
     DIFF_YEARS: {
         handler(args) {
-            return differenceInYears_1.default(args[0], args[1]);
+            const [first, second] = dateUtils_1.normalizeDateParams(args);
+            const result = differenceInYears_1.default(first, second);
+            return isNaN(result) ? '' : result;
         },
         description: 'Returns the difference in years between 2 dates',
         signatures: ['DIFF_YEARS(a: date, b: date)'],

package/src/Utilities/Extensions/StringExtensions.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StringExtensions = exports.IsNumeric = exports.ReplaceEmptySpacesWithUnderscore = exports.Humanize = exports.CapitaliseFirstLetter = exports.AbbreviateString = exports.NotIncludes = exports.Includes = exports.ToLowerCase = exports.RemoveTrailingComma = exports.CamelCaseToHumanText = exports.IsNotNullOrEmptyOrWhiteSpace = exports.IsNullOrEmptyOrWhiteSpace = exports.IsNotNullOrEmpty = exports.IsNullOrEmpty = exports.IsNotEmpty = exports.IsEmpty = exports.IsNotNull = exports.IsNull = void 0;
 const tslib_1 = require("tslib");
-const startCase_1 = tslib_1.__importDefault(require("lodash-es/startCase"));
+const startCase_1 = tslib_1.__importDefault(require("lodash/startCase"));
 function IsNull(stringToCheck) {
     return stringToCheck == null || stringToCheck == undefined;
 }

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -2,8 +2,8 @@
 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;
 const tslib_1 = require("tslib");
-const cloneDeepWith_1 = tslib_1.__importDefault(require("lodash-es/cloneDeepWith"));
-const isPlainObject_1 = tslib_1.__importDefault(require("lodash-es/isPlainObject"));
+const cloneDeepWith_1 = tslib_1.__importDefault(require("lodash/cloneDeepWith"));
+const isPlainObject_1 = tslib_1.__importDefault(require("lodash/isPlainObject"));
 const LoggingHelper_1 = require("./LoggingHelper");
 const Uuid_1 = require("../../PredefinedConfig/Uuid");
 const DefaultAdaptableOptions_1 = require("../Defaults/DefaultAdaptableOptions");
@@ -13,6 +13,7 @@ function assignAdaptableOptions(adaptableOptions) {
     returnedAdaptableOptions.adaptableStateKey = (_a = returnedAdaptableOptions.adaptableStateKey) !== null && _a !== void 0 ? _a : returnedAdaptableOptions.adaptableId;
     returnedAdaptableOptions.layoutOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.layoutOptions, adaptableOptions.layoutOptions);
     returnedAdaptableOptions.notificationsOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.notificationsOptions, adaptableOptions.notificationsOptions);
+    returnedAdaptableOptions.alertOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.alertOptions, adaptableOptions.alertOptions);
     returnedAdaptableOptions.flashingCellOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.flashingCellOptions, adaptableOptions.flashingCellOptions);
     returnedAdaptableOptions.entitlementOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.entitlementOptions, adaptableOptions.entitlementOptions);
     returnedAdaptableOptions.dashboardOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dashboardOptions, adaptableOptions.dashboardOptions);