@adaptabletools/adaptable 12.0.8 → 12.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "12.0.8",
+  "version": "12.0.9",
   "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: 1657781105254;
+declare const _default: 1657803750403;
 export default _default;

package/publishTimestamp.js

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

package/src/Api/EventApi.d.ts

@@ -16,6 +16,7 @@ import { GridDataChangedInfo } from './Events/GridDataChanged';
 import { TeamSharingEntityChangedInfo } from './Events/TeamSharingEntityChanged';
 import { ActionRowSubmittedInfo } from './Events/ActionRowSubmitted';
 import { DataSetSelectedInfo } from './Events/DataSetSelected';
+import { AdaptableStateReloadedInfo } from './Events/AdaptableStateReloaded';
 /**
  * Responsible for publishing the many Events that AdapTable fires
  */
@@ -183,6 +184,17 @@ export interface EventApi {
      * Unsubscribe from AdaptableStateChanged
      */
     off(eventName: 'AdaptableStateChanged', callback: (adaptableStateChangedInfo: AdaptableStateChangedInfo) => void): void;
+    /**
+     * Event fired whenever **Adaptable State is reloaded**
+     * @param eventName AdaptableStateReloaded
+     * @param callback AdaptableStateReloadedInfo
+     * @returns the unsubscribe function
+     */
+    on(eventName: 'AdaptableStateReloaded', callback: (adaptableStateReloadedInfo: AdaptableStateReloadedInfo) => void): () => void;
+    /**
+     * Unsubscribe from AdaptableStateReloaded
+     */
+    off(eventName: 'AdaptableStateReloaded', callback: (adaptableStateReloadedInfo: AdaptableStateReloadedInfo) => void): void;
     /**
      * Event fired whenever **a change occurs relating to live reports / data**
      * Used in conjunction with AdapTable's partners OpenFin, ipushpull or Glue42
@@ -252,6 +264,6 @@ export interface EventApi {
     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' | 'ActionRowSubmitted' | 'DataSetSelected', data?: any): Promise<any>;
+    emit(eventName: 'AdaptableReady' | 'AlertFired' | 'CheckboxColumnClicked' | 'CustomToolbarConfigured' | 'AdaptableStateChanged' | 'AdaptableStateReloaded' | 'DashboardChanged' | 'CellChanged' | 'GridDataChanged' | 'LayoutChanged' | 'LiveDataChanged' | 'SearchChanged' | 'SelectionChanged' | 'SystemStatusMessageDisplayed' | 'TeamSharingEntityChanged' | 'ThemeChanged' | 'FDC3MessageSent' | 'ActionRowSubmitted' | 'DataSetSelected', data?: any): Promise<any>;
     destroy(): void;
 }

package/src/Api/Events/AdaptableStateReloaded.d.ts

@@ -0,0 +1,23 @@
+import { AdaptablePersistentState } from '../../PredefinedConfig/AdaptableState';
+import { BaseEventInfo } from './BaseEventInfo';
+/**
+ * Object returned by the `AdaptableStateReloaded` event
+ */
+export interface AdaptableStateReloadedInfo extends BaseEventInfo {
+    /**
+     * Current AdapTableId
+     */
+    adaptableId: string;
+    /**
+     * Current Adaptable State Key
+     */
+    adaptableStateKey: string;
+    /**
+     * Adaptable State before the reload
+     */
+    oldState: AdaptablePersistentState;
+    /**
+     * Adaptable State after the reload
+     */
+    newState: AdaptablePersistentState;
+}

package/src/Api/Events/AdaptableStateReloaded.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Api/Implementation/ConfigApiImpl.js

@@ -48,6 +48,7 @@ class ConfigApiImpl extends ApiBase_1.ApiBase {
     reloadPredefinedConfig(newPredefinedConfig) {
         var _a;
         const adaptableOptions = this.adaptable.adaptableOptions;
+        const oldState = this.getPersistedState();
         const clearStateFn = ((_a = adaptableOptions.stateOptions) === null || _a === void 0 ? void 0 : _a.clearState) ||
             (() => {
                 localStorage.removeItem(adaptableOptions.adaptableStateKey);
@@ -63,6 +64,16 @@ class ConfigApiImpl extends ApiBase_1.ApiBase {
                 this.setAdaptableStateKey(adaptableOptions.adaptableStateKey, {
                     predefinedConfig: newPredefinedConfig || adaptableOptions.predefinedConfig,
                     flushCurrentState: false,
+                }).then(() => {
+                    const newState = this.getPersistedState();
+                    const stateReloadedInfo = {
+                        oldState,
+                        newState,
+                        adaptableStateKey: adaptableOptions.adaptableStateKey,
+                        adaptableId: adaptableOptions.adaptableId,
+                        adaptableApi: this.adaptable.api,
+                    };
+                    this.adaptable.api.eventApi.emit('AdaptableStateReloaded', stateReloadedInfo);
                 });
             });
         });

package/src/Redux/Store/AdaptableStore.js

@@ -570,7 +570,7 @@ const adaptableMiddleware = (adaptable) => function (middlewareAPI) {
                             .getCalculatedColumnExpressionService()
                             .createAggregatedScalarCalculatedColumn(calculatedColumn);
                     });
-                    // refresh calcualted columns
+                    // refresh calculated columns
                     const aggCalculatedColumnIds = aggregatedCalculatedColumns.map((calculatedColumn) => calculatedColumn.ColumnId);
                     adaptable.refreshCells(null, aggCalculatedColumnIds, true);
                     return;

package/src/Strategy/AdaptableModuleBase.d.ts

@@ -12,6 +12,7 @@ import { AccessLevel } from '../PredefinedConfig/Common/Entitlement';
 import { CalculatedColumn } from '../PredefinedConfig/CalculatedColumnState';
 import { FreeTextColumn } from '../PredefinedConfig/FreeTextColumnState';
 import { AdaptableInternalIconName } from '../PredefinedConfig/Common/AdaptableIcon';
+import { AdaptableStateReloadedInfo } from '../Api/Events/AdaptableStateReloaded';
 /**
  * Base class for all strategies and does most of the work of creating menus
  */
@@ -34,6 +35,7 @@ export declare abstract class AdaptableModuleBase implements IModule {
     getReferencedNamedQueryNames(adaptableObject: AdaptableObject): string[];
     hasNamedQueryReferences(): boolean;
     handleAdaptableReady(): void;
+    handleConfigReloaded(adaptableStateReloadedInfo: AdaptableStateReloadedInfo): void;
     setModuleEntitlement(): void;
     addModuleMenuItem(source: 'ModuleMenu' | 'ModuleButton'): AdaptableMenuItem | undefined;
     addModuleButtonMenuItem(): AdaptableMenuItem | undefined;

package/src/Strategy/AdaptableModuleBase.js

@@ -24,6 +24,9 @@ class AdaptableModuleBase {
             this.handleAdaptableReady();
             this.api.configApi.dispatchStateReadyAction(this.moduleInfo.ModuleName);
         });
+        this.api.eventApi.on('AdaptableStateReloaded', (adaptableStateReloadedInfo) => {
+            this.handleConfigReloaded(adaptableStateReloadedInfo);
+        });
     }
     getViewAccessLevel() {
         // override where necessary (ex. only 'Full' accessLevel should be displayed)
@@ -68,6 +71,9 @@ class AdaptableModuleBase {
     handleAdaptableReady() {
         // override where necessary in base classes
     }
+    handleConfigReloaded(adaptableStateReloadedInfo) {
+        // override where necessary in base classes
+    }
     setModuleEntitlement() {
         this.AccessLevel = this.api.internalApi
             .getEntitlementService()

package/src/Strategy/CalculatedColumnModule.d.ts

@@ -8,8 +8,10 @@ import { CalculatedColumn } from '../PredefinedConfig/CalculatedColumnState';
 import { AdaptableObjectItemView, IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
+import { AdaptableStateReloadedInfo } from '../Api/Events/AdaptableStateReloaded';
 export declare class CalculatedColumnModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
+    handleConfigReloaded(adaptableStateReloadedInfo: AdaptableStateReloadedInfo): void;
     getModuleAdaptableObjects(): AdaptableObject[];
     updateOldConfig(): void;
     getExplicitlyReferencedColumnIds(calculatedColumn: CalculatedColumn): string[];

package/src/Strategy/CalculatedColumnModule.js

@@ -15,6 +15,10 @@ class CalculatedColumnModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.CalculatedColumnModuleId, 'Calculated Column', 'calculated-column', 'CalculatedColumnPopup', 'Create bespoke columns whose cell value is derived dynamically from an Expression', api);
     }
+    handleConfigReloaded(adaptableStateReloadedInfo) {
+        // re-dispatch the CalculatedColumnReady action to recreate all the aggregated scalar columns
+        this.api.internalApi.dispatchReduxAction(CalculatedColumnRedux.CalculatedColumnReady(this.api.calculatedColumnApi.getCalculatedColumnState()));
+    }
     getModuleAdaptableObjects() {
         return this.api.calculatedColumnApi.getAllCalculatedColumn();
     }

package/src/Strategy/TeamSharingModule.js

@@ -32,10 +32,12 @@ class TeamSharingModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             // make sure there is no zombie import process remaining (in case a previous import crashed)
             this.api.internalApi.dispatchReduxAction(TeamSharingRedux.TeamSharingCommitImport());
         });
-        this.api.teamSharingApi.triggerLoadingTeamSharingEntries();
+        if (this.api.teamSharingApi.isTeamSharingAvailable()) {
+            this.api.teamSharingApi.triggerLoadingTeamSharingEntries();
+        }
     }
     isModuleAvailable() {
-        return super.isModuleAvailable() && this.api.teamSharingApi.isTeamSharingActivated();
+        return super.isModuleAvailable() && this.api.teamSharingApi.isTeamSharingAvailable();
     }
     isModuleObjectsShareable() {
         return false;

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -177,6 +177,11 @@ exports.aggregatedScalarExpressionFunctions = {
                                 }
                                 return rowValue < minValue ? rowValue : minValue;
                             },
+                            done: (minValue) => {
+                                if (minValue !== Number.MAX_VALUE) {
+                                    return minValue;
+                                }
+                            },
                         },
                     },
                 },
@@ -218,6 +223,11 @@ exports.aggregatedScalarExpressionFunctions = {
                                 }
                                 return rowValue > maxValue ? rowValue : maxValue;
                             },
+                            done: (maxValue) => {
+                                if (maxValue !== Number.MIN_VALUE) {
+                                    return maxValue;
+                                }
+                            },
                         },
                     },
                 },

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -29,6 +29,16 @@ class CalculatedColumnExpressionService {
                 this.adaptableApi.gridApi.refreshCells(null, refreshedCalculatedColumns);
             }
         });
+        this.adaptableApi.eventApi.on('GridDataChanged', () => {
+            const refreshedCalculatedColumns = [];
+            this.aggregatedScalarCalculatedColumnsMap.forEach((aggregatedScalarCalculatedColumn) => {
+                aggregatedScalarCalculatedColumn.refreshAggregatedColumnValue();
+                refreshedCalculatedColumns.push(aggregatedScalarCalculatedColumn.getCalculatedColumnId());
+            });
+            if (refreshedCalculatedColumns.length) {
+                this.adaptableApi.gridApi.refreshCells(null, refreshedCalculatedColumns);
+            }
+        });
     }
     destroy() {
         [...this.aggregatedScalarCalculatedColumnsMap.values()].forEach((aggregatedScalarCalculatedColumn) => aggregatedScalarCalculatedColumn.destroy());
@@ -116,10 +126,7 @@ class CalculatedColumnExpressionService {
         // 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 aggregationConfig = this.adaptableApi.internalApi
-                .getQueryLanguageService()
-                .evaluateAggregatedScalarExpression(calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
-            const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(aggregationConfig.value, calculatedColumn, this.adaptableApi);
+            const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(calculatedColumn, this.adaptableApi);
             this.aggregatedScalarCalculatedColumnsMap.set(calculatedColumn.Uuid, aggregatedScalarCalculatedColumn);
         }
     }
@@ -131,13 +138,16 @@ class CalculatedColumnExpressionService {
 }
 exports.CalculatedColumnExpressionService = CalculatedColumnExpressionService;
 class AggregatedScalarCalculatedColumn {
-    constructor(expressionEvaluation, calculatedColumn, adaptableApi) {
-        this.expressionEvaluation = expressionEvaluation;
+    constructor(calculatedColumn, adaptableApi) {
         this.calculatedColumn = calculatedColumn;
         this.adaptableApi = adaptableApi;
-        this.aggregationResult = this.computeAggregatedValue(expressionEvaluation);
+        const aggregationConfig = this.adaptableApi.internalApi
+            .getQueryLanguageService()
+            .evaluateAggregatedScalarExpression(calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
+        this.expressionEvaluation = aggregationConfig.value;
+        this.aggregationResult = this.computeAggregatedValue(this.expressionEvaluation);
         // currently we support only one reducer
-        this.aggregationReducerName = Object.keys(expressionEvaluation.aggregationParams.reducers)[0];
+        this.aggregationReducerName = Object.keys(this.expressionEvaluation.aggregationParams.reducers)[0];
     }
     destroy() {
         this.expressionEvaluation = null;
@@ -153,6 +163,10 @@ class AggregatedScalarCalculatedColumn {
         return aggregationValue;
     }
     refreshAggregatedColumnValue() {
+        const aggregationConfig = this.adaptableApi.internalApi
+            .getQueryLanguageService()
+            .evaluateAggregatedScalarExpression(this.calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
+        this.expressionEvaluation = aggregationConfig.value;
         this.aggregationResult = this.computeAggregatedValue(this.expressionEvaluation);
     }
     getCalculatedColumnId() {
@@ -167,11 +181,13 @@ class AggregatedScalarCalculatedColumn {
         // we iterate over the RowNode list (we need this to handle complex column values (nested values, valueGetters etc)
         // so we will map the fieldNames to RowNode.data
         const mapReducerValueGetter = (fieldName) => {
-            return (rowNode) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, fieldName);
+            return (rowNode) => {
+                return this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, fieldName);
+            };
         };
         Object.values(expressionEvaluation.aggregationParams.reducers).forEach((aggregationReducer) => {
             aggregationReducer.getter = mapReducerValueGetter(aggregationReducer.field);
-            // nullify the getter to force the fallback on the getter fn
+            // nullify the field to force the fallback on the getter fn
             aggregationReducer.field = null;
         });
         const mapGroupByToKey = (fieldName) => {

package/src/agGrid/Adaptable.d.ts

@@ -95,6 +95,7 @@ export declare class Adaptable implements IAdaptable {
     private listenerGlobalSetRowSelection;
     private listenerGlobalColumnEventsThatTriggerStateChange;
     private listenerGlobalColumnEventsThatTriggerAutoLayoutSave;
+    private listenerGlobalRowGroupEventsThatTriggerAutoLayoutSave;
     static init(adaptableOptions: AdaptableOptions): Promise<AdaptableApi>;
     /**
      * Lazy static constructor for Adaptable

package/src/agGrid/Adaptable.js

@@ -2515,6 +2515,7 @@ class Adaptable {
             this.gridOptions.api.removeGlobalListener(this.listenerGlobalSetRowSelection);
             this.gridOptions.api.removeGlobalListener(this.listenerGlobalColumnEventsThatTriggerStateChange);
             this.gridOptions.api.removeGlobalListener(this.listenerGlobalColumnEventsThatTriggerAutoLayoutSave);
+            this.gridOptions.api.removeGlobalListener(this.listenerGlobalRowGroupEventsThatTriggerAutoLayoutSave);
             this.listenerFirstDataRendered = null;
             this.listenerPivotModeChanged = null;
             this.listenerPivotChanged = null;
@@ -2526,6 +2527,7 @@ class Adaptable {
             this.listenerModelUpdated = null;
             this.listenerGlobalColumnEventsThatTriggerStateChange = null;
             this.listenerGlobalColumnEventsThatTriggerAutoLayoutSave = null;
+            this.listenerGlobalRowGroupEventsThatTriggerAutoLayoutSave = null;
             this.gridOptions.api.__adaptable = null;
             this.gridOptions.api.setColumnDefs = GridApi_setColumnDefs;
             this.gridOptions.getRowStyle = null;
@@ -2759,7 +2761,6 @@ class Adaptable {
             all_modules_1.Events.EVENT_DISPLAYED_COLUMNS_CHANGED,
             all_modules_1.Events.EVENT_SORT_CHANGED,
             all_modules_1.Events.EVENT_COLUMN_ROW_GROUP_CHANGED,
-            all_modules_1.Events.EVENT_ROW_GROUP_OPENED,
             all_modules_1.Events.EVENT_COLUMN_VALUE_CHANGED,
         ];
         // ADD filter event
@@ -2768,6 +2769,18 @@ class Adaptable {
                 this.debouncedSaveGridLayout();
             }
         }));
+        // Save Layout if Display Row Groups is "dynamic"
+        const rowGroupEventsThatTriggersAutoLayoutSave = [
+            all_modules_1.Events.EVENT_ROW_GROUP_OPENED,
+            all_modules_1.Events.EVENT_EXPAND_COLLAPSE_ALL,
+        ];
+        this.gridOptions.api.addGlobalListener((this.listenerGlobalRowGroupEventsThatTriggerAutoLayoutSave = (type) => {
+            if (rowGroupEventsThatTriggersAutoLayoutSave.indexOf(type) > -1) {
+                if (this.adaptableOptions.layoutOptions.displayRowGroups == 'dynamic') {
+                    this.debouncedSaveGridLayout();
+                }
+            }
+        }));
         /**
          * Use Case: A visible Column has become row grouped and 'hideColumnWhenGrouped' is true
          * Action: Make the column invisible