@adaptabletools/adaptable 11.2.0-canary.0 → 11.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "11.2.0-canary.0",
+  "version": "11.2.1",
   "description": "Powerful data-agnostic HTML5 datagrid add-on that sits on top of an underlying grid component and provides all the rich functionality that advanced users expect from their DataGrids and Data Tables",
   "keywords": [
     "web-components",

package/publishTimestamp.d.ts

@@ -1,2 +1,2 @@
-declare const _default: 1652263696641;
+declare const _default: 1652706790076;
 export default _default;

package/publishTimestamp.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = 1652263696641;
+exports.default = 1652706790076;

package/src/Api/EventApi.d.ts

@@ -205,12 +205,25 @@ export interface EventApi {
      * ```
      */
     on(eventName: 'AdaptableReady', callback: (adaptableReadyInfo: AdaptableReadyInfo) => void): VoidFunction;
+    /**
+     * Fired when Adaptable is destroyed
+     * @param eventName - AdaptableDestroy
+     * @param callback - A callback for listening to `AdaptableDestroy`
+     * @returns the unsubscribe function
+     *
+     * @example Use as
+     * ```
+     * adaptableApi.eventApi.on('AdaptableDestroy', () => { .....[do stuff]...})
+     * ```
+     */
+    on(eventName: 'AdaptableDestroy', callback: () => void): VoidFunction;
     /**
      * Unsubscribe from AdaptableReady
      */
     off(eventName: 'AdaptableReady', callback: (adaptableReadyInfo: AdaptableReadyInfo) => void): void;
     emitSync(eventName: 'DashboardChanged', data?: any): any[];
     emitSync(eventName: 'FlashingCellDisplayed', data?: any): any[];
+    emitSync(eventName: 'AdaptableDestroy'): any[];
     emit(eventName: 'AdaptableReady' | 'AlertFired' | 'CheckboxColumnClicked' | 'CustomToolbarConfigured' | 'AdaptableStateChanged' | 'DashboardChanged' | 'CellChanged' | 'GridDataChanged' | 'LayoutChanged' | 'LiveDataChanged' | 'SearchChanged' | 'SelectionChanged' | 'SystemStatusMessageDisplayed' | 'TeamSharingEntityChanged' | 'ThemeChanged' | 'FDC3MessageSent', data?: any): Promise<any>;
     destroy(): void;
 }

package/src/Api/Implementation/EventApiImpl.js

@@ -24,6 +24,7 @@ class EventApiImpl extends ApiBase_1.ApiBase {
         this.emitter = new Emitter_1.default();
     }
     destroy() {
+        this.emitSync('AdaptableDestroy');
         this.emitter.destroy();
     }
 }

package/src/Utilities/Emitter.js

@@ -18,6 +18,11 @@ function assertListener(listener) {
 }
 function getListeners(instance, eventName) {
     const events = eventsMap.get(instance);
+    if (!events) {
+        // we're hitting this case only when calling `off` after the instance has been destroyed (so extremely rarely)
+        // so we want to return an empty set in order not to make the code throw an error
+        return new Set();
+    }
     if (!events.has(eventName)) {
         events.set(eventName, new Set());
     }

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

@@ -7,10 +7,10 @@ export declare class AlertService implements IAlertService {
     private emitter;
     private reactiveAlertsMap;
     constructor(adaptableApi: AdaptableApi);
+    destroy(): void;
     onReactiveAlertTriggered: (callback: EmitterCallback) => (() => void);
     createReactiveAlert(alertDefinition: AlertDefinition): void;
     deleteReactiveAlert(alertDefinition: AlertDefinition): void;
-    destroy(): void;
     private isValidExpression;
     private evaluateReactiveExpression;
 }

package/src/Utilities/Services/AlertService.js

@@ -15,6 +15,13 @@ class AlertService {
         };
         this.emitter = new Emitter_1.default();
     }
+    destroy() {
+        this.emitter.destroy();
+        this.emitter = null;
+        this.reactiveAlertsMap.forEach((alertsSubscriptionInfo) => alertsSubscriptionInfo.subscription.unsubscribe());
+        this.reactiveAlertsMap.clear();
+        this.reactiveAlertsMap = null;
+    }
     createReactiveAlert(alertDefinition) {
         // if there is already a reactive alert for this definition, delete it (possible in case of editing definitions),
         this.deleteReactiveAlert(alertDefinition);
@@ -51,11 +58,6 @@ class AlertService {
             this.reactiveAlertsMap.delete(alertDefinition.Uuid);
         }
     }
-    destroy() {
-        this.emitter.destroy();
-        this.emitter = null;
-        this.reactiveAlertsMap.forEach((alertsSubscriptionInfo) => alertsSubscriptionInfo.subscription.unsubscribe());
-    }
     isValidExpression(rule) {
         return rule.ObservableExpression
             ? this.adaptableApi.queryLanguageApi.isValidObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with observable expression `)

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

@@ -6,10 +6,10 @@ export declare class CalculatedColumnExpressionService implements ICalculatedCol
     private adaptableApi;
     private aggregatedScalarCalculatedColumnsMap;
     constructor(adaptableApi: AdaptableApi);
+    destroy(): void;
     getCalculatedColumnDataType(calculatedColumnQuery: AdaptableCalculatedColumnQuery): 'String' | 'Number' | 'Boolean' | 'Date';
     isCalculatedColumnQueryValid(calculatedColumnQuery: AdaptableCalculatedColumnQuery): boolean;
     evaluateCalculatedColumnQuery(calculatedColumn: CalculatedColumn, node: RowNode): any;
     createAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
     destroyAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
-    destroy(): void;
 }

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -31,6 +31,11 @@ class CalculatedColumnExpressionService {
             }
         });
     }
+    destroy() {
+        [...this.aggregatedScalarCalculatedColumnsMap.values()].forEach((aggregatedScalarCalculatedColumn) => aggregatedScalarCalculatedColumn.destroy());
+        this.aggregatedScalarCalculatedColumnsMap.clear();
+        this.aggregatedScalarCalculatedColumnsMap = null;
+    }
     getCalculatedColumnDataType(calculatedColumnQuery) {
         try {
             if (calculatedColumnQuery.AggregatedScalarExpression) {
@@ -120,11 +125,10 @@ class CalculatedColumnExpressionService {
         }
     }
     destroyAggregatedScalarCalculatedColumn(calculatedColumn) {
+        var _a;
+        (_a = this.aggregatedScalarCalculatedColumnsMap.get(calculatedColumn.Uuid)) === null || _a === void 0 ? void 0 : _a.destroy();
         this.aggregatedScalarCalculatedColumnsMap.delete(calculatedColumn.Uuid);
     }
-    destroy() {
-        // TO DO
-    }
 }
 exports.CalculatedColumnExpressionService = CalculatedColumnExpressionService;
 class AggregatedScalarCalculatedColumn {
@@ -136,6 +140,12 @@ class AggregatedScalarCalculatedColumn {
         // currently we support only one reducer
         this.aggregationReducerName = Object.keys(expressionEvaluation.aggregationParams.reducers)[0];
     }
+    destroy() {
+        this.expressionEvaluation = null;
+        this.calculatedColumn = null;
+        this.adaptableApi = null;
+        this.aggregationResult = null;
+    }
     getAggregatedColumnValue(rowNode) {
         const aggregationValue = this.getAggregationValue(rowNode);
         if (this.expressionEvaluation.rowValueGetter) {

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

@@ -6,17 +6,17 @@ import { Observable } from 'rxjs';
 export declare class DataService implements IDataService {
     private adaptable;
     private emitter;
-    private readonly dataChangeLogSubject$;
+    private dataChangeLogSubject$;
     dataChangeLog$: Observable<CellDataChangedInfo>;
     private undoChangeLog;
     private undoChangeTimers;
     constructor(adaptable: IAdaptable);
+    destroy(): void;
     on: (eventName: string, callback: EmitterCallback) => (() => void);
     emit: (eventName: string, data?: any) => Promise<any>;
     CreateDataChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
     logUndoChange(change: CellDataChangedInfo): void;
     extractUndoChange(change: CellDataChangedInfo): CellDataChangedInfo | undefined;
-    destroy(): void;
     private getUndoChangeKey;
     private logDataChange;
     private extractDataChangeLogEntry;

package/src/Utilities/Services/DataService.js

@@ -20,6 +20,17 @@ class DataService {
         this.undoChangeLog = new Map();
         this.undoChangeTimers = new Map();
     }
+    destroy() {
+        this.emitter.destroy();
+        this.emitter = null;
+        this.dataChangeLogSubject$.complete();
+        this.dataChangeLogSubject$ = null;
+        this.dataChangeLog$ = null;
+        this.undoChangeLog.clear();
+        this.undoChangeLog = null;
+        this.undoChangeTimers.clear();
+        this.undoChangeTimers = null;
+    }
     CreateDataChangedEvent(cellDataChangedInfo) {
         if (cellDataChangedInfo.newValue != cellDataChangedInfo.oldValue) {
             this.emitter.emitSync('CellDataChanged', cellDataChangedInfo);
@@ -57,10 +68,6 @@ class DataService {
         }
         return result;
     }
-    destroy() {
-        this.emitter.destroy();
-        this.emitter = null;
-    }
     getUndoChangeKey(primaryKeyValue, columnId, previousValue, newValue) {
         return JSON.stringify({
             primaryKeyValue,

package/src/Utilities/Services/ValidationService.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const ArrayExtensions_1 = require("../Extensions/ArrayExtensions");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
 const ModuleConstants_1 = require("../Constants/ModuleConstants");
+const ObjectFactory_1 = tslib_1.__importDefault(require("../ObjectFactory"));
 class ValidationService {
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
@@ -51,6 +52,10 @@ class ValidationService {
                 cellDataChangedInfo: cellDataChangedInfo,
             };
             this.adaptableApi.alertApi.publishAlertFiredEvent(alert);
+            failedRules.forEach((alertDefinition) => {
+                const alert = ObjectFactory_1.default.CreateCellChangedAlert(cellDataChangedInfo.column.friendlyName, this.adaptableApi.alertApi.getAlertDescription(alertDefinition, cellDataChangedInfo), alertDefinition, cellDataChangedInfo);
+                this.adaptableApi.alertApi.displayAlert(alert);
+            });
             return false;
         }
         return true;

package/src/View/Components/Popups/AdaptableToaster.js

@@ -7,10 +7,19 @@ const ObjectFactory_1 = tslib_1.__importDefault(require("../../../Utilities/Obje
 const AdaptablePopupAlert_1 = require("./AdaptablePopupAlert");
 const react_toastify_1 = require("react-toastify");
 exports.showToast = (props) => {
+    // we're doing this hack and not simply using props.api in order not to have a memory
+    // leak where the api is still kept around in memory by the toaster
+    let api = props.api;
+    const off = api.eventApi.on('AdaptableDestroy', () => {
+        api = null;
+    });
     const toastProps = ObjectFactory_1.default.CreateToastOptions(props.api.internalApi.getAdaptableOptions().notificationsOptions, {
         onClose: () => {
-            if (!props.api.isDestroyed()) {
-                props.api.internalApi.hidePopupAlert();
+            if (api) {
+                off();
+                if (!api.isDestroyed()) {
+                    api.internalApi.hidePopupAlert();
+                }
             }
         },
     });

package/src/agGrid/Adaptable.d.ts

@@ -103,7 +103,7 @@ export declare class Adaptable implements IAdaptable {
      */
     static initInternal(adaptableOptions: AdaptableOptions, runtimeConfig?: RuntimeConfig): Promise<AdaptableApi>;
     private static collectInstance;
-    private static forEachAdaptable;
+    static forEachAdaptable(fn: (adaptable: Adaptable) => void): void;
     private static dismissInstance;
     constructor();
     init(adaptableOptions: AdaptableOptions, runtimeConfig?: RuntimeConfig, _staticInit?: boolean): Promise<AdaptableApi>;

package/src/agGrid/Adaptable.js

@@ -84,6 +84,43 @@ const assignColId = (colDef) => {
 const RowNodeProto = all_modules_1.RowNode.prototype;
 const RowNode_dispatchLocalEvent = RowNodeProto.dispatchLocalEvent;
 const GridApi_setColumnDefs = all_modules_1.GridApi.prototype.setColumnDefs;
+/**
+ * AgGrid does not expose Events.EVENT_ROW_DATA_CHANGED
+ * so we have to override `dispatchLocalEvent`
+ * and hook our own functionality into it
+ */
+RowNodeProto.dispatchLocalEvent = function (event) {
+    const node = event.node;
+    const result = RowNode_dispatchLocalEvent.apply(this, arguments);
+    const extractGridApiFromRowNode = (rowNode) => {
+        var _a, _b;
+        // starting with AG Grid 26.1.0 the gridApi is wrapped in a Beans property
+        const rowNodeApi = (_b = (_a = rowNode) === null || _a === void 0 ? void 0 : _a.beans) === null || _b === void 0 ? void 0 : _b.gridApi;
+        if (!rowNodeApi) {
+            LoggingHelper_1.LogAdaptableWarning(`No GridAPI found in passed RowNode, this should never happen!`, rowNode);
+        }
+        return rowNodeApi;
+    };
+    // we don't know from which instance of aggrid this is coming,
+    // as this fn is shared by all instances
+    if (node) {
+        Adaptable.forEachAdaptable((adaptable) => {
+            if (extractGridApiFromRowNode(node) !== adaptable.gridOptions.api) {
+                // the event is coming from another aggrid instance
+                // so IGNORE IT
+                return;
+            }
+            // we're on the correct instance, so do this
+            //@ts-ignore
+            const fn = adaptable.rowListeners ? adaptable.rowListeners[event.type] : null;
+            if (fn) {
+                console.log('fire event', event);
+                fn(event);
+            }
+        });
+    }
+    return result;
+};
 /**
  * Since column definitions can be nested and have groups
  * we use this forEachColumn function to call the passed-in `fn`
@@ -704,6 +741,7 @@ class Adaptable {
         this._emit('GridFiltered');
         this.setSelectedCells();
         this.setSelectedRows();
+        this.updateColumnFilterActiveState();
     }
     isGroupRowNode(rowNode) {
         if (!rowNode) {
@@ -2365,16 +2403,27 @@ class Adaptable {
         this.gridOptions = null;
         this.adaptableOptions = null;
         (_b = this.CalculatedColumnExpressionService) === null || _b === void 0 ? void 0 : _b.destroy();
+        this.CalculatedColumnExpressionService = null;
         (_c = this.DataService) === null || _c === void 0 ? void 0 : _c.destroy();
+        this.DataService = null;
         (_d = this.EntitlementService) === null || _d === void 0 ? void 0 : _d.destroy();
+        this.EntitlementService = null;
         (_e = this.ReportService) === null || _e === void 0 ? void 0 : _e.destroy();
+        this.ReportService = null;
         (_f = this.ModuleService) === null || _f === void 0 ? void 0 : _f.destroy();
+        this.ModuleService = null;
         (_g = this.ValidationService) === null || _g === void 0 ? void 0 : _g.destroy();
+        this.ValidationService = null;
         (_h = this.QueryLanguageService) === null || _h === void 0 ? void 0 : _h.destroy();
+        this.QueryLanguageService = null;
         (_j = this.AlertService) === null || _j === void 0 ? void 0 : _j.destroy();
+        this.AlertService = null;
         (_k = this.TeamSharingService) === null || _k === void 0 ? void 0 : _k.destroy();
+        this.TeamSharingService = null;
         (_l = this.MetamodelService) === null || _l === void 0 ? void 0 : _l.destroy();
+        this.MetamodelService = null;
         (_m = this.LicenseService) === null || _m === void 0 ? void 0 : _m.destroy();
+        this.LicenseService = null;
         this.isDestroyed = true;
     }
     // really really need to do this properly but as a temp fix lets create a default style for when no data
@@ -2659,59 +2708,15 @@ class Adaptable {
                 }
             },
         };
-        /**
-         * AgGrid does not expose Events.EVENT_ROW_DATA_CHANGED
-         * so we have to override `dispatchLocalEvent`
-         * and hook our own functionality into it
-         */
-        RowNodeProto.dispatchLocalEvent = function (event) {
-            const node = event.node;
-            const result = RowNode_dispatchLocalEvent.apply(this, arguments);
-            const extractGridApiFromRowNode = (rowNode) => {
-                var _a, _b;
-                // starting with AG Grid 26.1.0 the gridApi is wrapped in a Beans property
-                const rowNodeApi = (_b = (_a = rowNode) === null || _a === void 0 ? void 0 : _a.beans) === null || _b === void 0 ? void 0 : _b.gridApi;
-                if (!rowNodeApi) {
-                    LoggingHelper_1.LogAdaptableWarning(`No GridAPI found in passed RowNode, this should never happen!`, rowNode);
-                }
-                return rowNodeApi;
-            };
-            // we don't know from which instance of aggrid this is coming,
-            // as this fn is shared by all instances
-            if (node) {
-                Adaptable.forEachAdaptable((adaptable) => {
-                    if (extractGridApiFromRowNode(node) !== adaptable.gridOptions.api) {
-                        // the event is coming from another aggrid instance
-                        // so IGNORE IT
-                        return;
-                    }
-                    // we're on the correct instance, so do this
-                    const fn = adaptable.rowListeners ? adaptable.rowListeners[event.type] : null;
-                    if (fn) {
-                        fn(event);
-                    }
-                });
-            }
-            return result;
-        };
         // We plug our filter mechanism and if there is already something like external widgets... we save ref to the function
         const original_isExternalFilterPresent = this.gridOptions.isExternalFilterPresent;
         this.gridOptions.isExternalFilterPresent = (params) => {
+            if (this.isDestroyed) {
+                return true;
+            }
             const columnFilters = this.api.filterApi.getAllColumnFilter();
             const isFilterActive = ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(columnFilters);
             const isQueryActive = StringExtensions_1.StringExtensions.IsNotNullOrEmpty(this.api.queryApi.getCurrentQuery());
-            /**
-             * Changing the column filterState sync breaks the rendering of the custom filter component.
-             * I think that changing the column definition while ag-grid determines if a column is filtered
-             * breaks the logic of the custom component.
-             *
-             * Result:
-             * - custom filters in sate
-             * - refresh page, the ag-grid filter is rendered instead of adaptable custom-filter-component.
-             */
-            requestAnimationFrame(() => {
-                this.updateColumnFilterActiveState();
-            });
             return (isFilterActive ||
                 isQueryActive ||
                 // it means that originaldoesExternalFilterPass will be called so we reinit that collection
@@ -2721,6 +2726,9 @@ class Adaptable {
         const evaluateQueryOnClient = this.api.internalApi.runModuleInAdaptableQL('Query');
         const evaluateFilterOnClient = this.api.internalApi.runModuleInAdaptableQL('Filter');
         this.gridOptions.doesExternalFilterPass = (node) => {
+            if (this.isDestroyed) {
+                return true;
+            }
             // first we assess Query (if its running locally)
             if (evaluateQueryOnClient && !this.isGroupRowNode(node)) {
                 const currentQuery = this.api.queryApi.getCurrentQuery();
@@ -2769,22 +2777,32 @@ class Adaptable {
     updateColumnFilterActiveState() {
         const columnFilters = this.api.filterApi.getAllColumnFilter();
         const isFilterActive = ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(columnFilters);
+        const columnsWithActiveFilters = {};
         if (isFilterActive) {
             // used in particular at init time to show the filter icon correctly
             for (const colFilter of columnFilters) {
                 const agGridCol = this.gridOptions.columnApi.getColumn(colFilter.ColumnId);
-                if (agGridCol && !agGridCol.isFilterActive()) {
-                    agGridCol.setFilterActive(true);
+                if (agGridCol) {
+                    columnsWithActiveFilters[agGridCol.getColId()] = true;
+                    if (!agGridCol.isFilterActive()) {
+                        agGridCol.setFilterActive(true);
+                    }
                 }
             }
         }
-        else {
-            (this.gridOptions.columnApi.getAllColumns() || []).forEach((col) => {
-                if (col.isFilterActive()) {
-                    col.setFilterActive(false);
-                }
-            });
-        }
+        const agFilterModel = this.gridOptions.api.getFilterModel();
+        (this.gridOptions.columnApi.getAllColumns() || []).forEach((col) => {
+            /**
+             * When ag-grid filters are used active state should not be removed for all columns.
+             * Need to check if the column has a filter model.
+             */
+            const isColumnInFilterModel = agFilterModel && agFilterModel[col.getColId()];
+            if (!isColumnInFilterModel &&
+                !columnsWithActiveFilters[col.getColId()] &&
+                col.isFilterActive()) {
+                col.setFilterActive(false);
+            }
+        });
     }
     buildStandaloneColumnHeader(adaptableColumn) {
         return this.agGridMenuHelper.buildStandaloneColumnHeader(adaptableColumn);
@@ -2855,7 +2873,15 @@ class Adaptable {
             this.gridOptionsPropertyCache.set(userKey, value);
         }
         const userValue = this.gridOptionsPropertyCache.get(userKey);
-        const adaptableValue = propertyGetter(userValue);
+        const adaptableValue = (...args) => {
+            if (this.isDestroyed) {
+                return;
+            }
+            if (propertyGetter) {
+                return propertyGetter(userValue)(...args);
+            }
+            return undefined;
+        };
         if (adaptableValue != null) {
             this.gridOptionsPropertyCache.set(adaptableKey, adaptableValue);
         }
@@ -3212,7 +3238,14 @@ class Adaptable {
                 if (cellDataChangedInfo.oldValue === cellDataChangedInfo.newValue) {
                     return true;
                 }
-                if (!this.ValidationService.performValidation(cellDataChangedInfo)) {
+                /**
+                 * Validate on the future row, with the new value.
+                 * structuredClone fails, it contains functions.
+                 */
+                const newRow = Object.assign(Object.assign({}, params.node), { data: Object.assign({}, params.node.data) });
+                newRow.data[field] = params.newValue;
+                const cellDataChangeInfoForSyncValidation = Object.assign(Object.assign({}, cellDataChangedInfo), { rowNode: newRow });
+                if (!this.ValidationService.performValidation(cellDataChangeInfoForSyncValidation)) {
                     return false;
                 }
                 const onServerValidationCompleted = () => { };

package/src/metamodel/adaptable.metamodel.js

@@ -5195,6 +5195,12 @@ exports.ADAPTABLE_METAMODEL = {
                 "description": "Fired when Adaptable is up and running - has no arguments.",
                 "uiLabel": "On"
             },
+            {
+                "name": "on",
+                "kind": "function",
+                "description": "Fired when Adaptable is destroyed",
+                "uiLabel": "On"
+            },
             {
                 "name": "on",
                 "kind": "function",

package/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "11.2.0-canary.0";
+declare const _default: "11.2.1";
 export default _default;

package/version.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = '11.2.0-canary.0'; // PLEASE DONT UPDATE THIS!!! - will be updated at build time with the correct version
+exports.default = '11.2.1'; // PLEASE DONT UPDATE THIS!!! - will be updated at build time with the correct version