@adaptabletools/adaptable 12.0.9 → 12.1.0-canary.2

package/src/Strategy/Utilities/{getCustomSortSortOrderViewItems.d.ts → CustomSort/getCustomSortSortOrderViewItems.d.ts}

@@ -1,4 +1,4 @@
-import { CustomSort } from '../../../types';
+import { CustomSort } from '../../../../types';
 export declare const getCustomSortSortOrderViewItems: (customSort: CustomSort) => {
     name: string;
     values: string[];

package/src/Strategy/Utilities/Export/getExportColumnsViewItems.d.ts

@@ -0,0 +1,3 @@
+import { AdaptableApi, Report } from '../../../../types';
+import { AdaptableObjectItemView } from '../../Interface/IModule';
+export declare const getExportColumnsViewItems: (report: Report, api: AdaptableApi) => AdaptableObjectItemView;

package/src/Strategy/Utilities/{getFlashingCellDurationViewItems.d.ts → FlashingCell/getFlashingCellDurationViewItems.d.ts}

@@ -1,4 +1,4 @@
-import { FlashingCellDefinition } from '../../../types';
+import { FlashingCellDefinition } from '../../../../types';
 export declare const getFlashingCellDurationViewItems: (flashingCell: FlashingCellDefinition) => {
     name: string;
     values: (number | "always")[];

package/src/Strategy/Utilities/{getFlashingCellStyleViewItems.d.ts → FlashingCell/getFlashingCellStyleViewItems.d.ts}

@@ -1,2 +1,2 @@
-import { AdaptableObjectItemView } from '../Interface/IModule';
+import { AdaptableObjectItemView } from '../../Interface/IModule';
 export declare const getFlashingCellStyleViewItems: () => AdaptableObjectItemView;

package/src/Strategy/Utilities/{getFlashingCellStyleViewItems.js → FlashingCell/getFlashingCellStyleViewItems.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFlashingCellStyleViewItems = void 0;
-const FlashingCellStyle_1 = require("../../View/FlashingCell/FlashingCellStyle");
+const FlashingCellStyle_1 = require("../../../View/FlashingCell/FlashingCellStyle");
 const getFlashingCellStyleViewItems = () => {
     return {
         name: 'Flash Styles',

package/src/Strategy/Utilities/{getFlashingTargetViewItems.d.ts → FlashingCell/getFlashingTargetViewItems.d.ts}

@@ -1,5 +1,5 @@
 import { FlashingCellDefinition } from '../../../types';
 export declare const getFlashingTargetViewItems: (flashingCell: FlashingCellDefinition) => {
     name: string;
-    values: import("../../PredefinedConfig/FlashingCellState").FlashTargetTypes[];
+    values: import("../../../PredefinedConfig/FlashingCellState").FlashTargetTypes[];
 };

package/src/Strategy/Utilities/{getFormatColumnSettingsViewItems.d.ts → FormatColumn/getFormatColumnSettingsViewItems.d.ts}

@@ -1,4 +1,4 @@
-import { FormatColumn } from '../../../types';
+import { FormatColumn } from '../../../../types';
 export declare const getFormatColumnSettingsViewItems: (calculatedColumn: FormatColumn) => {
     name: string;
     values: string[];

package/src/Strategy/Utilities/{getFormatColumnStyleViewItems.js → FormatColumn/getFormatColumnStyleViewItems.js}

@@ -4,7 +4,7 @@ exports.getFormatColumnStyleViewItems = void 0;
 const tslib_1 = require("tslib");
 const React = tslib_1.__importStar(require("react"));
 const rebass_1 = require("rebass");
-const FormatColumnStyleWizardSection_1 = require("../../View/FormatColumn/Wizard/FormatColumnStyleWizardSection");
+const FormatColumnStyleWizardSection_1 = require("../../../View/FormatColumn/Wizard/FormatColumnStyleWizardSection");
 const getFormatColumnStyleViewItems = (formatColumn, api) => {
     return React.createElement(rebass_1.Box, { mt: 2 }, FormatColumnStyleWizardSection_1.renderFormatColumnStyleSummary(formatColumn, api));
 };

package/src/Strategy/Utilities/Layout/getLayoutFilterViewItems.d.ts

@@ -0,0 +1,5 @@
+import { AdaptableApi, Layout } from '../../../../types';
+export declare const getLayoutFilterViewItems: (layout: Layout, api: AdaptableApi) => {
+    name: string;
+    values: string[];
+};

package/src/Strategy/Utilities/Layout/getLayoutFilterViewItems.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLayoutFilterViewItems = void 0;
+const getLayoutFilterViewItems = (layout, api) => {
+    var _a;
+    const columnIdToFriendlyName = (columnId) => {
+        return api.columnApi.getFriendlyNameFromColumnId(columnId);
+    };
+    return {
+        name: 'Filter',
+        values: ((_a = layout.ColumnFilters) !== null && _a !== void 0 ? _a : []).map((customFilter) => `[${columnIdToFriendlyName(customFilter.ColumnId)}: ${customFilter.Predicate.PredicateId} ${customFilter.Predicate.Inputs.map((input) => {
+            if (typeof input === 'string') {
+                return input;
+            }
+            if (typeof (input === null || input === void 0 ? void 0 : input.toString) === 'function') {
+                return input.toString();
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join(', ')}]`),
+    };
+};
+exports.getLayoutFilterViewItems = getLayoutFilterViewItems;

package/src/Strategy/Utilities/Layout/getLayoutSortViewItems.d.ts

@@ -0,0 +1,5 @@
+import { AdaptableApi, Layout } from '../../../types';
+export declare const getLayoutSortViewItems: (layout: Layout, api: AdaptableApi) => {
+    name: string;
+    values: string[];
+};

package/src/Strategy/Utilities/Layout/getLayoutSortViewItems.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLayoutSortViewItems = void 0;
+const getLayoutSortViewItems = (layout, api) => {
+    var _a;
+    const columnIdToFriendlyName = (columnId) => {
+        return api.columnApi.getFriendlyNameFromColumnId(columnId);
+    };
+    return {
+        name: 'Sort',
+        values: ((_a = layout.ColumnSorts) !== null && _a !== void 0 ? _a : []).map((customSort) => `[${columnIdToFriendlyName(customSort.ColumnId)}: ${customSort.SortOrder}]`),
+    };
+};
+exports.getLayoutSortViewItems = getLayoutSortViewItems;

package/src/Strategy/Utilities/{getShortcutSettingsViewItems.d.ts → Shortcut/getShortcutSettingsViewItems.d.ts}

@@ -1,4 +1,4 @@
-import { Shortcut } from '../../../types';
+import { Shortcut } from '../../../../types';
 export declare const getShortcutSettingsViewItems: (shortcut: Shortcut) => {
     name: string;
     values: string[];

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

@@ -6,7 +6,7 @@ import { AggregateParams } from './scalarAggregationHelper';
  * List of all the AggregatedScalar Functions available in AdaptableQL
  */
 export declare type AggregatedScalarFunctionName = AggregationFunction | OperandFunction;
-declare type AggregationFunction = 'SUM' | 'PERCENTAGE' | 'AVG' | 'MIN' | 'MAX' | 'CUMUL';
+declare type AggregationFunction = 'SUM' | 'PERCENTAGE' | 'QUANT' | 'AVG' | 'MIN' | 'MAX' | 'CUMUL';
 declare type OperandFunction = 'COL' | 'OVER' | 'GROUP_BY';
 export interface AggregationParameter extends BaseParameter<'aggregation', AggregationFunction> {
     value: AggregatedScalarExpressionEvaluation;
@@ -19,9 +19,11 @@ export interface GroupByParameter extends BaseParameter<'operand', 'GROUP_BY'> {
 }
 export interface AggregatedScalarExpressionEvaluation {
     aggregationParams: AggregateParams<any, string | number>;
-    rowValueGetter?: (rowNode: RowNode, aggregationValue: number) => string | number | Date | boolean;
+    rowValueGetter?: (rowNode: RowNode, aggregatedValue: any) => string | number | Date | boolean;
     columnDependencies: string[];
     cumulateOver?: string;
+    sortByColumn?: string;
+    filterUndefinedValues?: boolean;
 }
 export declare const aggregatedScalarExpressionFunctions: Record<AggregatedScalarFunctionName, ExpressionFunction>;
 export {};

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -114,6 +114,140 @@ exports.aggregatedScalarExpressionFunctions = {
             'PERCENTAGE( [colNameA], SUM ( [colNameB], GROUP_BY( [colNameC] )))',
         ],
     },
+    QUANT: {
+        handler(args, context) {
+            var _a, _b, _c;
+            const quantileColumnParameter = expressionFunctionUtils_1.extractColumnParameter('QUANT', args);
+            const quantileColumnName = quantileColumnParameter.value;
+            expressionFunctionUtils_1.validateColumnType(quantileColumnName, ['Number'], 'QUANT', context.adaptableApi);
+            const qNumber = args.find((arg) => typeof arg === 'number');
+            if (qNumber == null || qNumber <= 0) {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('QUANT', 'expects a positive number as argument');
+            }
+            const groupByOperand = expressionFunctionUtils_1.extractParameter('QUANT', 'operand', ['GROUP_BY'], args, true);
+            const groupByColumnName = groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value;
+            let quantReducer;
+            if (groupByColumnName) {
+                // do the heavy-lifting in done()
+                quantReducer = {
+                    initialValue: new WeakMap(),
+                    reducer: (nodeValueMap, rowValue, rowNode, rowIndex) => {
+                        if (!rowValue) {
+                            return nodeValueMap;
+                        }
+                        nodeValueMap.set(rowNode, rowValue);
+                        return nodeValueMap;
+                    },
+                    done: (nodeValueMap, groupItems) => {
+                        var _a, _b;
+                        const populationSize = (_b = (_a = groupItems === null || groupItems === void 0 ? void 0 : groupItems.filter((rowNode) => {
+                            const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
+                            return rowValue != undefined;
+                        })) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+                        const bucketsMap = new Map();
+                        for (let step = 1; step <= qNumber; step++) {
+                            bucketsMap.set(step, populationSize * (step / qNumber));
+                        }
+                        const indexBucketMap = new Map();
+                        for (let populationIndex = 0; populationIndex < populationSize; populationIndex++) {
+                            for (let quantIndex = 1; quantIndex <= qNumber; quantIndex++) {
+                                if (bucketsMap.get(quantIndex) < populationIndex + 1) {
+                                    continue;
+                                }
+                                else {
+                                    indexBucketMap.set(populationIndex, quantIndex);
+                                    break;
+                                }
+                            }
+                        }
+                        const groupedRowBucketMap = new Map();
+                        groupItems.forEach((subgroupRowNode, subgroupRowIndex) => {
+                            const subgroupRowValue = nodeValueMap.get(subgroupRowNode);
+                            if (subgroupRowValue) {
+                                groupedRowBucketMap.set(subgroupRowValue, indexBucketMap.get(subgroupRowIndex));
+                            }
+                        });
+                        return groupedRowBucketMap;
+                    },
+                };
+            }
+            else {
+                // in case of non-grouped quantiles, we are able to calculate the buckets beforehand (which is the most efficient)
+                const populationSize = (_c = (_b = (_a = context.adaptableApi.gridApi.getAllRowNodes()) === null || _a === void 0 ? void 0 : _a.filter((rowNode) => {
+                    const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
+                    return rowValue != undefined;
+                })) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+                const bucketsMap = new Map();
+                for (let step = 1; step <= qNumber; step++) {
+                    bucketsMap.set(step, populationSize * (step / qNumber));
+                }
+                const indexBucketMap = new Map();
+                for (let populationIndex = 0; populationIndex < populationSize; populationIndex++) {
+                    for (let quantIndex = 1; quantIndex <= qNumber; quantIndex++) {
+                        if (bucketsMap.get(quantIndex) < populationIndex + 1) {
+                            continue;
+                        }
+                        else {
+                            indexBucketMap.set(populationIndex, quantIndex);
+                            break;
+                        }
+                    }
+                }
+                quantReducer = {
+                    initialValue: new Map(),
+                    reducer: (rowBucketMap, rowValue, rowNode, rowIndex) => {
+                        if (!rowValue) {
+                            return rowBucketMap;
+                        }
+                        rowBucketMap.set(rowValue, indexBucketMap.get(rowIndex));
+                        return rowBucketMap;
+                    },
+                };
+            }
+            const aggregationExpressionEvaluation = {
+                sortByColumn: quantileColumnName,
+                filterUndefinedValues: true,
+                aggregationParams: {
+                    reducers: {
+                        QUANT: Object.assign({ name: 'QUANT', field: quantileColumnName }, quantReducer),
+                    },
+                },
+                rowValueGetter: (rowNode, rowBucketMap) => {
+                    const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
+                    if (rowValue == null) {
+                        return;
+                    }
+                    return rowBucketMap.get(rowValue);
+                },
+                columnDependencies: [quantileColumnName],
+            };
+            if (groupByColumnName) {
+                aggregationExpressionEvaluation.aggregationParams.groupBy = [
+                    {
+                        field: groupByColumnName,
+                    },
+                ];
+                aggregationExpressionEvaluation.columnDependencies.push(groupByColumnName);
+            }
+            const result = {
+                name: 'QUANT',
+                type: 'aggregation',
+                value: aggregationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Calculates the q-Quantiles of the given group and displays which q-quantile the given value is in\nCommon quantiles are 4-quantile or Quartile, 5-quantile or Quintile, 10-quantile or Decile and 100-quantile or Percentile',
+        signatures: [
+            'QUANT( [colName], q: number)',
+            'QUANT( COL(name: string), q: number)',
+            'QUANT( [colName1], q: number, GROUP_BY([colName2]) )',
+        ],
+        examples: [
+            'QUANT( [col1], 5)',
+            `QUANT( COL('col1'), 100))`,
+            'QUANT( [col1], 4, GROUP_BY([col2]) )',
+        ],
+    },
     AVG: {
         handler(args, context) {
             const avgColumnParameter = expressionFunctionUtils_1.extractColumnParameter('AVG', args);

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

@@ -14,7 +14,7 @@ export declare type DataAggregationReducer<T, AggregationResultType> = {
     field?: keyof T & string;
     initialValue?: AggregationResultType;
     getter?: (data: T) => any;
-    reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
+    reducer: string | ((accumulator: any, value: any, data: T, dataIndex: number) => AggregationResultType | any);
     done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
 };
 export declare type DataAggregationResult<DataType, KeyType extends any> = {

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -28,11 +28,11 @@ function aggregate(aggregateParams, data) {
             const { items: currentGroupItems, reducerResults } = deepMap.get(currentGroupKeys);
             currentGroupItems.push(item);
             if (reducers) {
-                computeReducersFor(item, reducers, reducerResults);
+                computeReducersFor(item, reducers, reducerResults, i);
             }
         }
         if (reducers) {
-            computeReducersFor(item, reducers, globalReducerResults);
+            computeReducersFor(item, reducers, globalReducerResults, i);
         }
         currentGroupKeys.length = 0;
     }
@@ -77,11 +77,11 @@ function cumulate(aggregateParams, data) {
             const { items: currentGroupItems, reducerResults } = deepMap.get(currentGroupKeys);
             currentGroupItems.push(item);
             if (reducers) {
-                computeReducersFor(item, reducers, reducerResults);
+                computeReducersFor(item, reducers, reducerResults, i);
             }
         }
         if (reducers) {
-            computeReducersFor(item, reducers, globalReducerResults);
+            computeReducersFor(item, reducers, globalReducerResults, i);
         }
         initialReducerValue = Object.assign({}, deepMap.get(currentGroupKeys).reducerResults);
         currentGroupKeys.length = 0;
@@ -124,7 +124,7 @@ function initReducers(reducers) {
  * @param reducerResults the results on which to operate
  *
  */
-function computeReducersFor(data, reducers, reducerResults) {
+function computeReducersFor(data, reducers, reducerResults, dataIndex) {
     var _a, _b;
     if (!reducers || !Object.keys(reducers).length) {
         return;
@@ -137,7 +137,7 @@ function computeReducersFor(data, reducers, reducerResults) {
             }
             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);
+            reducerResults[key] = reducer.reducer(currentValue, value, data, dataIndex);
         }
 }
 function completeReducers(reducers, reducerResults, items) {

package/src/Utilities/ObjectFactory.d.ts

@@ -25,9 +25,9 @@ import { SystemStatusMessageInfo } from '../PredefinedConfig/Common/SystemStatus
 import { NotificationsOptions } from '../AdaptableOptions/NotificationsOptions';
 import { CellSummmary } from '../PredefinedConfig/Common/CellSummary';
 import { ColumnFilter, CustomDisplayFormatterContext, FlashingCellDefinition, GridDataChangedInfo, SystemFilterPredicateId } from '../types';
-import { ToastOptions } from 'react-toastify';
 import { RowNode } from '@ag-grid-community/all-modules';
 import { AdaptableApi } from '../../types';
+import type { ToastOptions } from 'react-toastify';
 export declare function CreateEmptyCustomSort(): CustomSort;
 export declare function CreateEmptyCalculatedColumn(isFilterable: boolean): CalculatedColumn;
 export declare function CreateEmptyNamedQuery(expression?: string): NamedQuery;

package/src/Utilities/ObjectFactory.js

@@ -4,7 +4,7 @@ exports.ObjectFactory = exports.CreateToastOptions = exports.CreateCustomDisplay
 const Enums_1 = require("../PredefinedConfig/Common/Enums");
 const GeneralConstants_1 = require("./Constants/GeneralConstants");
 const Uuid_1 = require("../PredefinedConfig/Uuid");
-const react_toastify_1 = require("react-toastify");
+const { toast, Bounce, Flip, Slide, Zoom } = require('react-toastify');
 function CreateEmptyCustomSort() {
     return { Uuid: Uuid_1.createUuid(), ColumnId: GeneralConstants_1.EMPTY_STRING, SortedValues: [] };
 }
@@ -146,6 +146,7 @@ function CreateEmptyReminderSchedule() {
         Message: GeneralConstants_1.EMPTY_STRING,
         MessageType: 'Info',
         DisplayNotification: true,
+        DisplaySystemStatusMessage: false,
     };
 }
 exports.CreateEmptyReminderSchedule = CreateEmptyReminderSchedule;
@@ -392,29 +393,29 @@ exports.CreateToastOptions = CreateToastOptions;
 function getToastPosition(position) {
     switch (position) {
         case 'BottomLeft':
-            return react_toastify_1.toast.POSITION.BOTTOM_LEFT;
+            return toast.POSITION.BOTTOM_LEFT;
         case 'BottomCenter':
-            return react_toastify_1.toast.POSITION.BOTTOM_CENTER;
+            return toast.POSITION.BOTTOM_CENTER;
         case 'BottomRight':
-            return react_toastify_1.toast.POSITION.BOTTOM_RIGHT;
+            return toast.POSITION.BOTTOM_RIGHT;
         case 'TopLeft':
-            return react_toastify_1.toast.POSITION.TOP_LEFT;
+            return toast.POSITION.TOP_LEFT;
         case 'TopCenter':
-            return react_toastify_1.toast.POSITION.TOP_CENTER;
+            return toast.POSITION.TOP_CENTER;
         case 'TopRight':
-            return react_toastify_1.toast.POSITION.TOP_RIGHT;
+            return toast.POSITION.TOP_RIGHT;
     }
 }
 function getToastTransition(transition) {
     switch (transition) {
         case 'Bounce':
-            return react_toastify_1.Bounce;
+            return Bounce;
         case 'Slide':
-            return react_toastify_1.Slide;
+            return Slide;
         case 'Zoom':
-            return react_toastify_1.Zoom;
+            return Zoom;
         case 'Flip':
-            return react_toastify_1.Flip;
+            return Flip;
     }
 }
 exports.ObjectFactory = {

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -122,12 +122,17 @@ class CalculatedColumnExpressionService {
         }
     }
     createAggregatedScalarCalculatedColumn(calculatedColumn) {
-        var _a;
+        var _a, _b;
         // if there is already an aggregated scalar, delete it (possible when editing)
         this.destroyAggregatedScalarCalculatedColumn(calculatedColumn);
         if ((_a = calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.AggregatedScalarExpression) {
-            const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(calculatedColumn, this.adaptableApi);
-            this.aggregatedScalarCalculatedColumnsMap.set(calculatedColumn.Uuid, aggregatedScalarCalculatedColumn);
+            try {
+                const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(calculatedColumn, this.adaptableApi);
+                this.aggregatedScalarCalculatedColumnsMap.set(calculatedColumn.Uuid, aggregatedScalarCalculatedColumn);
+            }
+            catch (e) {
+                LoggingHelper_1.LogAdaptableError(`Creating CalculatedColumn ('${(_b = calculatedColumn.Query) === null || _b === void 0 ? void 0 : _b.AggregatedScalarExpression}') failed!\n${e.message}`);
+            }
         }
     }
     destroyAggregatedScalarCalculatedColumn(calculatedColumn) {
@@ -197,7 +202,30 @@ class AggregatedScalarCalculatedColumn {
             groupByDef.toKey = mapGroupByToKey(groupByDef.field);
         });
         if (!expressionEvaluation.cumulateOver) {
-            return scalarAggregationHelper_1.aggregate(expressionEvaluation.aggregationParams, gridRowNodes);
+            let aggregatedRowNodes = gridRowNodes;
+            if (expressionEvaluation.sortByColumn) {
+                const sortByColumn = expressionEvaluation.sortByColumn;
+                const getRowNodeValue = (rowNode, columnId) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, columnId);
+                if (expressionEvaluation.filterUndefinedValues) {
+                    aggregatedRowNodes = gridRowNodes.filter((node) => {
+                        const rowValue = getRowNodeValue(node, sortByColumn);
+                        return rowValue != undefined;
+                    });
+                }
+                // currently, we support only ascending sorting
+                aggregatedRowNodes.sort((first, second) => {
+                    const firstValue = getRowNodeValue(first, sortByColumn);
+                    const secondValue = getRowNodeValue(second, sortByColumn);
+                    if (firstValue < secondValue) {
+                        return -1;
+                    }
+                    if (firstValue > secondValue) {
+                        return 1;
+                    }
+                    return 0;
+                });
+            }
+            return scalarAggregationHelper_1.aggregate(expressionEvaluation.aggregationParams, aggregatedRowNodes);
         }
         else {
             // 1. sort grid data by given OVER column

package/src/View/AdaptableView.js

@@ -13,9 +13,9 @@ const AdaptableLoadingScreen_1 = require("./Components/Popups/AdaptableLoadingSc
 const renderWithAdaptableContext_1 = require("./renderWithAdaptableContext");
 const License_1 = require("./License");
 const ProgressIndicator_1 = require("../components/ProgressIndicator/ProgressIndicator");
-const react_toastify_1 = require("react-toastify");
 const WindowPopups_1 = require("./Components/Popups/WindowPopups/WindowPopups");
 const FormPopups_1 = require("./Components/Popups/FormPopups/FormPopups");
+const { ToastContainer } = require('react-toastify');
 class AdaptableView extends React.Component {
     render() {
         var _a, _b, _c, _d;
@@ -27,7 +27,7 @@ class AdaptableView extends React.Component {
             this.props.PopupState.PromptPopup.ShowPromptPopup && (React.createElement(AdaptablePopupPrompt_1.AdaptablePopupPrompt, { message: this.props.PopupState.PromptPopup.Message, header: this.props.PopupState.PromptPopup.Header, onClose: this.props.onClosePromptPopup, onConfirm: this.props.onConfirmPromptPopup, onConfirmActionCreator: this.props.PopupState.PromptPopup.ConfirmActionCreator, defaultValue: this.props.PopupState.PromptPopup.DefaultValue })),
             React.createElement(AdaptablePopupConfirmation_1.AdaptablePopupConfirmation, { header: this.props.PopupState.ConfirmationPopup.Header, messsage: this.props.PopupState.ConfirmationPopup.Msg, showPopup: this.props.PopupState.ConfirmationPopup.ShowConfirmationPopup, cancelButtonText: this.props.PopupState.ConfirmationPopup.CancelButtonText, confirmButtonText: this.props.PopupState.ConfirmationPopup.ConfirmButtonText, onCancel: this.props.onCancelConfirmationPopup, onConfirm: this.props.onConfirmConfirmationPopup, showInputBox: this.props.PopupState.ConfirmationPopup.ShowInputBox, messageType: this.props.PopupState.ConfirmationPopup.MessageType, api: this.props.AdaptableApi }),
             Boolean(this.props.PopupState.ScreenPopup.ShowScreenPopup) && (React.createElement(AdaptablePopup_1.AdaptablePopup, { componentName: this.props.PopupState.ScreenPopup.ComponentName, componentModule: this.props.PopupState.ScreenPopup.ComponentModule, onHide: this.props.onCloseScreenPopup, api: this.props.AdaptableApi, onClearParams: () => this.props.onClearPopupParams(), moduleParams: this.props.PopupState.ScreenPopup.Params, moduleProps: this.props.PopupState.ScreenPopup.PopupProps })),
-            React.createElement(react_toastify_1.ToastContainer
+            React.createElement(ToastContainer
             // we NEEEEED!!!! this containerId, otherwise, toastify will have memory leaks when the adaptable
             // instance is destroyed and re-created many times
             , { 

package/src/View/Components/AdaptableObjectList/AdaptableObjectList.d.ts

@@ -1,5 +1,30 @@
 import * as React from 'react';
-import { AdaptableObjectView, IModule } from '../../../Strategy/Interface/IModule';
+import { Action } from 'redux';
+import { AdaptableObject } from '../../../PredefinedConfig/Common/AdaptableObject';
+import { AdaptableObjectItemView, AdaptableObjectView, IModule } from '../../../Strategy/Interface/IModule';
+import { AccessLevel, SharedEntityConfig } from '../../../types';
+export declare const AdaptableObjectListItemView: React.FunctionComponent<{
+    abObject: AdaptableObject;
+    accessLevel?: AccessLevel;
+    actions?: React.ReactElement[];
+    className?: string;
+    deleteAction?: Action;
+    onDelete?: () => void;
+    deleteDisabled?: boolean;
+    deleteTooltip?: string;
+    editDisabled?: boolean;
+    entityType: string;
+    handleOnEdit?: (tagName?: string) => void;
+    items: AdaptableObjectItemView[];
+    onShare?: (config: SharedEntityConfig) => void;
+    onSuspend?: () => void;
+    onUnSuspend?: () => void;
+    showActions?: boolean;
+    showEditButton?: boolean;
+    style?: React.CSSProperties;
+    suspendedEnabled?: boolean;
+    teamSharingActivated?: boolean;
+}>;
 interface AdaptableObjectListItemProps {
     data: AdaptableObjectView;
     module: IModule;
@@ -21,6 +46,7 @@ export declare const AdaptableObjectListItem: React.FunctionComponent<AdaptableO
 interface AdaptableObjectListProps {
     items: AdaptableObjectView[];
     module: IModule;
+    itemProps?: Partial<AdaptableObjectListItemProps>;
 }
 export declare const AdaptableObjectList: React.FunctionComponent<AdaptableObjectListProps>;
 export {};