@adaptabletools/adaptable 16.2.3 → 17.0.0-canary.0

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.booleanExpressionFunctionsNames = exports.booleanExpressionFunctions = void 0;
-const tslib_1 = require("tslib");
-const isAfter_1 = tslib_1.__importDefault(require("date-fns/isAfter"));
-const isBefore_1 = tslib_1.__importDefault(require("date-fns/isBefore"));
-const isEqual_1 = tslib_1.__importDefault(require("date-fns/isEqual"));
-const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
-const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
-const TypeExtensions_1 = require("../Extensions/TypeExtensions");
-exports.booleanExpressionFunctions = {
+import isAfter from 'date-fns/isAfter';
+import isBefore from 'date-fns/isBefore';
+import isEqual from 'date-fns/isEqual';
+import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
+import { getStringValue, getStringValues } from './expressionFunctionUtils';
+import { getTypedKeys } from '../Extensions/TypeExtensions';
+export const booleanExpressionFunctions = {
     TRUE: {
         handler: () => {
             return true;
@@ -39,6 +35,7 @@ exports.booleanExpressionFunctions = {
         signatures: ['statement AND statement'],
         examples: ['[col1] > 5 AND [col2] > 10'],
         returnType: 'boolean',
+        inputs: ['boolean', 'boolean'],
     },
     OR: {
         handler(args) {
@@ -50,6 +47,7 @@ exports.booleanExpressionFunctions = {
         signatures: ['statement OR statement'],
         examples: ['[col1] > 5 OR [col2] > 10'],
         returnType: 'boolean',
+        inputs: ['boolean', 'boolean'],
     },
     NOT: {
         handler(args) {
@@ -61,14 +59,15 @@ exports.booleanExpressionFunctions = {
         signatures: ['!statement'],
         examples: ['!([col1] > 5 AND [col2] > 10)'],
         returnType: 'boolean',
+        inputs: ['boolean'],
     },
     EQ: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isEqual_1.default)(args[0], args[1]);
+                return isEqual(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first == second;
             }
             return args[0] == args[1];
@@ -79,14 +78,20 @@ exports.booleanExpressionFunctions = {
         signatures: ['value = value', 'EQ(a: value, b: value)'],
         examples: ['[col1] = 5', 'EQ([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+            ['text', 'text'],
+            ['boolean', 'boolean'],
+        ],
     },
     NEQ: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return !(0, isEqual_1.default)(args[0], args[1]);
+                return !isEqual(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first != second;
             }
             return args[0] != args[1];
@@ -97,14 +102,20 @@ exports.booleanExpressionFunctions = {
         signatures: ['value != value', 'NEQ(a: value, b: value)'],
         examples: ['[col1] != 5', 'NEQ([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+            ['text', 'text'],
+            ['boolean', 'boolean'],
+        ],
     },
     LT: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isBefore_1.default)(args[0], args[1]);
+                return isBefore(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first < second;
             }
             return args[0] < args[1];
@@ -120,14 +131,19 @@ exports.booleanExpressionFunctions = {
         ],
         examples: ['[col1] < 5', 'LT([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+            ['text', 'text'],
+        ],
     },
     LTE: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isBefore_1.default)(args[0], args[1]) || (0, isEqual_1.default)(args[0], args[1]);
+                return isBefore(args[0], args[1]) || isEqual(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first <= second;
             }
             return args[0] <= args[1];
@@ -143,14 +159,19 @@ exports.booleanExpressionFunctions = {
         ],
         examples: ['[col1] <= 5', 'LTE([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+            ['text', 'text'],
+        ],
     },
     GT: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isAfter_1.default)(args[0], args[1]);
+                return isAfter(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first > second;
             }
             return args[0] > args[1];
@@ -166,14 +187,19 @@ exports.booleanExpressionFunctions = {
         ],
         examples: ['[col1] > 5', 'GT([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+            ['text', 'text'],
+        ],
     },
     GTE: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isAfter_1.default)(args[0], args[1]) || (0, isEqual_1.default)(args[0], args[1]);
+                return isAfter(args[0], args[1]) || isEqual(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first >= second;
             }
             return args[0] >= args[1];
@@ -189,11 +215,16 @@ exports.booleanExpressionFunctions = {
         ],
         examples: ['[col1] >= 5', 'GTE([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+            ['text', 'text'],
+        ],
     },
     BETWEEN: {
         handler([input, lower, upper]) {
             if (typeof input !== 'number')
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('BETWEEN', 'arg 1 should be a number');
+                throw new ExpressionEvaluationError('BETWEEN', 'arg 1 should be a number');
             return input >= lower && input <= upper;
         },
         category: 'comparison',
@@ -201,6 +232,7 @@ exports.booleanExpressionFunctions = {
         signatures: ['BETWEEN(input: number, lower: number, upper: number)'],
         examples: ['BETWEEN(5, [col1], [col2])'],
         returnType: 'boolean',
+        inputs: ['number', 'number', 'number'],
     },
     IN: {
         handler([needle, haystack]) {
@@ -214,7 +246,7 @@ exports.booleanExpressionFunctions = {
     },
     CONTAINS: {
         handler(args, context) {
-            const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+            const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
             return first.indexOf(second) !== -1;
         },
         category: 'strings',
@@ -222,10 +254,11 @@ exports.booleanExpressionFunctions = {
         signatures: ['CONTAINS(a: string, b: string)'],
         examples: ['CONTAINS([col1], "S")'],
         returnType: 'boolean',
+        inputs: ['text', 'text'],
     },
     STARTS_WITH: {
         handler(args, context) {
-            const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+            const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
             return first.startsWith(second);
         },
         category: 'strings',
@@ -233,10 +266,11 @@ exports.booleanExpressionFunctions = {
         signatures: ['STARTS_WITH(a: string, b: string)'],
         examples: ['STARTS_WITH([col1], "S")'],
         returnType: 'boolean',
+        inputs: ['text', 'text'],
     },
     ENDS_WITH: {
         handler(args, context) {
-            const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+            const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
             return first.endsWith(second);
         },
         category: 'strings',
@@ -244,15 +278,16 @@ exports.booleanExpressionFunctions = {
         signatures: ['ENDS_WITH(a: string, b: string)'],
         examples: ['ENDS_WITH([col1], "S")'],
         returnType: 'boolean',
+        inputs: ['text', 'text'],
     },
     ANY_CONTAINS: {
         handler(args, context) {
             var _a;
-            const searchTerm = (0, expressionFunctionUtils_1.getStringValue)(context, String(args[0]));
+            const searchTerm = getStringValue(context, String(args[0]));
             return (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.columnApi.getColumns().some((column) => {
                 var _a;
                 const value = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.gridApi.getDisplayValueFromRowNode(context.node, column.columnId);
-                const columnValue = (0, expressionFunctionUtils_1.getStringValue)(context, String(value));
+                const columnValue = getStringValue(context, String(value));
                 return columnValue.indexOf(searchTerm) !== -1;
             });
         },
@@ -263,4 +298,7 @@ exports.booleanExpressionFunctions = {
         returnType: 'boolean',
     },
 };
-exports.booleanExpressionFunctionsNames = (0, TypeExtensions_1.getTypedKeys)(exports.booleanExpressionFunctions);
+export const booleanExpressionFunctionsNames = getTypedKeys(booleanExpressionFunctions);
+export const isBooleanAdaptableQlFunction = (functionName) => {
+    return booleanExpressionFunctionsNames.includes(functionName);
+};

package/src/Utilities/ExpressionFunctions/dateUtils.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeDateParams = void 0;
-const normalizeDateParams = (args) => {
+export const normalizeDateParams = (args) => {
     let [first, second] = args;
     if (typeof first === 'string') {
         first = new Date(first);
@@ -11,4 +8,3 @@ const normalizeDateParams = (args) => {
     }
     return [first, second];
 };
-exports.normalizeDateParams = normalizeDateParams;

package/src/Utilities/ExpressionFunctions/deepMap.js

@@ -1,8 +1,5 @@
-"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 {
+export class DeepMap {
     constructor(initial) {
         this.map = new Map();
         this.length = 0;
@@ -266,7 +263,6 @@ class DeepMap {
         return makeIterator();
     }
 }
-exports.DeepMap = DeepMap;
 function once(fn) {
     let called = false;
     let result = null;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -1,57 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateColumnType = exports.getNumericValue = exports.handleColumnFunction = exports.extractParameters = exports.extractParameter = exports.extractColumnParameters = exports.extractColumnParameter = exports.evaluateExpressionNode = exports.handleWhereFunction = exports.getGridChangeLog$ = exports.getDataChangeLog$ = exports.isTextSearchCaseInsensitive = exports.getStringValue = exports.getStringValues = void 0;
-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/toNumber"));
-const evaluator_1 = require("../../parser/src/evaluator");
+import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
+import StringExtensions from '../Extensions/StringExtensions';
+import { filter } from 'rxjs/operators';
+import toNumber from 'lodash/toNumber';
+import { evaluateNode } from '../../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
-const getStringValues = (context, ...stringArguments) => {
-    return (0, exports.isTextSearchCaseInsensitive)(context)
+export const getStringValues = (context, ...stringArguments) => {
+    return isTextSearchCaseInsensitive(context)
         ? stringArguments.map((string) => string.toLowerCase())
         : stringArguments;
 };
-exports.getStringValues = getStringValues;
-const getStringValue = (context, stringArgument) => {
-    return (0, exports.isTextSearchCaseInsensitive)(context) ? stringArgument.toLowerCase() : stringArgument;
+export const getStringValue = (context, stringArgument) => {
+    return isTextSearchCaseInsensitive(context) ? stringArgument.toLowerCase() : stringArgument;
 };
-exports.getStringValue = getStringValue;
-const isTextSearchCaseInsensitive = (context) => !context.adaptableApi.expressionApi.useCaseSensitivity();
-exports.isTextSearchCaseInsensitive = isTextSearchCaseInsensitive;
+export const isTextSearchCaseInsensitive = (context) => !context.adaptableApi.expressionApi.useCaseSensitivity();
 // 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
-const getDataChangeLog$ = (context, columnNameFilter) => {
+export const getDataChangeLog$ = (context, columnNameFilter) => {
     let dataChangeLog$ = context.adaptableApi.internalApi.getDataService().dataChangeLog$;
     // filter only the given column changes
-    dataChangeLog$ = dataChangeLog$.pipe((0, operators_1.filter)((dataChangeLog) => dataChangeLog.column.columnId === columnNameFilter));
+    dataChangeLog$ = dataChangeLog$.pipe(filter((dataChangeLog) => dataChangeLog.column.columnId === columnNameFilter));
     // filter based on the WHERE clause
     if (context.filterFn) {
-        dataChangeLog$ = dataChangeLog$.pipe((0, operators_1.filter)((value) => {
+        dataChangeLog$ = dataChangeLog$.pipe(filter((value) => {
             return context.filterFn(value.rowNode);
         }));
     }
     return dataChangeLog$;
 };
-exports.getDataChangeLog$ = getDataChangeLog$;
-const getGridChangeLog$ = (context, gridChangeType) => {
+export const getGridChangeLog$ = (context, gridChangeType) => {
     const gridChangeLog$ = context.adaptableApi.internalApi.getDataService().gridChangeLog$;
-    let gridChangeStream$ = gridChangeLog$.pipe((0, operators_1.filter)((gridDataChangedInfo) => gridDataChangedInfo.rowTrigger === gridChangeType));
+    let gridChangeStream$ = gridChangeLog$.pipe(filter((gridDataChangedInfo) => gridDataChangedInfo.rowTrigger === gridChangeType));
     // filter based on the WHERE clause
     if (context.filterFn) {
-        gridChangeStream$ = gridChangeStream$.pipe((0, operators_1.filter)((value) => value.rowNodes.some((node) => context.filterFn(node))));
+        gridChangeStream$ = gridChangeStream$.pipe(filter((value) => value.rowNodes.some((node) => context.filterFn(node))));
     }
     return gridChangeStream$;
 };
-exports.getGridChangeLog$ = getGridChangeLog$;
-const handleWhereFunction = (args, context) => {
+export const handleWhereFunction = (args, context) => {
     const reactiveExpressionNode = args[0];
     const whereClauseExpressionNode = args[1];
     const filterFn = (rowNode) => {
         // whereClauseResult
-        return (0, evaluator_1.evaluateNode)(whereClauseExpressionNode, {
+        return evaluateNode(whereClauseExpressionNode, {
             node: rowNode,
             userName: context.adaptableApi.optionsApi.getUserName(),
             adaptableId: context.adaptableApi.optionsApi.getAdaptableId(),
@@ -61,11 +52,10 @@ const handleWhereFunction = (args, context) => {
         });
     };
     // observableExpressionResult
-    return (0, exports.evaluateExpressionNode)(reactiveExpressionNode, context, filterFn);
+    return evaluateExpressionNode(reactiveExpressionNode, context, filterFn);
 };
-exports.handleWhereFunction = handleWhereFunction;
-const evaluateExpressionNode = (expressionNode, context, filterFn = context.filterFn) => {
-    return (0, evaluator_1.evaluateNode)(expressionNode, {
+export const evaluateExpressionNode = (expressionNode, context, filterFn = context.filterFn) => {
+    return evaluateNode(expressionNode, {
         node: context.node,
         adaptableApi: context.adaptableApi,
         userName: context.adaptableApi.optionsApi.getUserName(),
@@ -75,41 +65,36 @@ const evaluateExpressionNode = (expressionNode, context, filterFn = context.filt
         evaluateCustomQueryVariable: context.adaptableApi.internalApi.getQueryLanguageService().evaluateCustomQueryVariable,
     });
 };
-exports.evaluateExpressionNode = evaluateExpressionNode;
-const extractColumnParameter = (consumingFunctionName, args) => {
-    return (0, exports.extractParameter)(consumingFunctionName, 'config', ['COL'], args);
+export const extractColumnParameter = (consumingFunctionName, args) => {
+    return extractParameter(consumingFunctionName, 'config', ['COL'], args);
 };
-exports.extractColumnParameter = extractColumnParameter;
-const extractColumnParameters = (consumingFunctionName, args) => {
-    return (0, exports.extractParameters)(consumingFunctionName, 'config', ['COL'], args);
+export const extractColumnParameters = (consumingFunctionName, args) => {
+    return extractParameters(consumingFunctionName, 'config', ['COL'], args);
 };
-exports.extractColumnParameters = extractColumnParameters;
-const extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
-    const parameters = (0, exports.extractParameters)(consumingFunctionName, allowedType, allowedOperands, args, config);
+export const extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
+    const parameters = extractParameters(consumingFunctionName, allowedType, allowedOperands, args, config);
     if (parameters == undefined) {
         return;
     }
     if (parameters.length > 1) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects only 1 argument of type '${[...new Set(parameters.map((op) => op.name))].join(`' / '`)}'`);
+        throw new ExpressionEvaluationError(consumingFunctionName, `expects only 1 argument of type '${[...new Set(parameters.map((op) => op.name))].join(`' / '`)}'`);
     }
     return parameters[0];
 };
-exports.extractParameter = extractParameter;
-const extractParameters = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
+export const extractParameters = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
     const { isOptional } = config !== null && config !== void 0 ? config : {};
     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;
     }
     if (!result.length) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects an argument of type '${allowedOperands.join(`' / '`)}'`);
+        throw new ExpressionEvaluationError(consumingFunctionName, `expects an argument of type '${allowedOperands.join(`' / '`)}'`);
     }
     return result;
 };
-exports.extractParameters = extractParameters;
-const handleColumnFunction = (args, context) => {
-    if (StringExtensions_1.default.IsNullOrEmpty(args[0])) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `no column name is provided`);
+export const handleColumnFunction = (args, context) => {
+    if (StringExtensions.IsNullOrEmpty(args[0])) {
+        throw new ExpressionEvaluationError('COL', `no column name is provided`);
     }
     validateColumnId(args[0], context.adaptableApi);
     const result = {
@@ -119,28 +104,25 @@ const handleColumnFunction = (args, context) => {
     };
     return result;
 };
-exports.handleColumnFunction = handleColumnFunction;
-const getNumericValue = (input) => {
+export const getNumericValue = (input) => {
     if (typeof input === 'number') {
         return input;
     }
-    const numericValue = (0, toNumber_1.default)(input);
+    const numericValue = toNumber(input);
     return isNaN(numericValue) ? 0 : numericValue;
 };
-exports.getNumericValue = getNumericValue;
-const validateColumnType = (columnId, validColumnTypes, consumingFunction, api) => {
+export const validateColumnType = (columnId, validColumnTypes, consumingFunction, api) => {
     const columnType = api.columnApi.getColumnDataTypeForColumnId(columnId);
     if (!validColumnTypes.some((validType) => validType === columnType)) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunction, `expects a column of type ${validColumnTypes.join(' or ')}`);
+        throw new ExpressionEvaluationError(consumingFunction, `expects a column of type ${validColumnTypes.join(' or ')}`);
     }
 };
-exports.validateColumnType = validateColumnType;
 const validateColumnId = (columnId, api) => {
     const column = api.columnApi.getColumnWithColumnId(columnId);
     if (!column) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError('', `Column name "${columnId}" is not found`);
+        throw new ExpressionEvaluationError('', `Column name "${columnId}" is not found`);
     }
     if (!column.queryable) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError('', `Column name "${columnId}" is not queryable`);
+        throw new ExpressionEvaluationError('', `Column name "${columnId}" is not queryable`);
     }
 };

package/src/Utilities/ExpressionFunctions/groupingMap.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.group = void 0;
-const deepMap_1 = require("./deepMap");
+import { DeepMap } from './deepMap';
 function DEFAULT_TO_KEY(value) {
     return value;
 }
-function group(groupParams, data) {
+export function group(groupParams, data) {
     const { groupBy, defaultToKey = DEFAULT_TO_KEY, reducers } = groupParams;
     const groupByLength = groupBy.length;
-    const deepMap = new deepMap_1.DeepMap();
+    const deepMap = new DeepMap();
     let currentGroupKeys = [];
     const initialReducerValue = initReducers(reducers);
     const globalReducerResults = Object.assign({}, initialReducerValue);
@@ -54,7 +51,6 @@ function group(groupParams, data) {
     };
     return result;
 }
-exports.group = group;
 function initReducers(reducers) {
     if (!reducers || !Object.keys(reducers).length) {
         return {};