@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.1

package/src/Redux/Store/AdaptableStore.js

@@ -4,6 +4,7 @@ import * as PopupRedux from '../ActionsReducers/PopupRedux';
 import { PROGRESS_INDICATOR_HIDE, PROGRESS_INDICATOR_SHOW } from '../ActionsReducers/PopupRedux';
 import { createEngine as createEngineLocal } from './AdaptableReduxLocalStorageEngine';
 import { mergeReducer } from './AdaptableReduxMerger';
+import { isRowChangeAlertDefinition } from '../../AdaptableState/AlertState';
 import { isAdaptableCellChangedAlert, isAdaptableRowChangedAlert, } from '../../AdaptableState/Common/AdaptableAlert';
 import { closeAgChartDefinitionIfOpen, closeExternalChartDefinitionIfOpen, } from '../../Utilities/Helpers/ChartHelper';
 import { refreshScheduledAlertJobs, refreshScheduledReportJobs, } from '../../Utilities/Helpers/Scheduling/ScheduledJobsMiddlewareHelper';
@@ -28,6 +29,7 @@ import * as FlashingCellRedux from '../ActionsReducers/FlashingCellRedux';
 import * as FormatColumnRedux from '../ActionsReducers/FormatColumnRedux';
 import * as FreeTextColumnRedux from '../ActionsReducers/FreeTextColumnRedux';
 import * as LayoutRedux from '../ActionsReducers/LayoutRedux';
+import { getAllLayoutExtensionObjects, hasLayoutExtensions, } from '../../Utilities/Helpers/Layouts/LayoutExtensionHelper';
 import * as NamedQueryRedux from '../ActionsReducers/NamedQueryRedux';
 import * as NoteRedux from '../ActionsReducers/NoteRedux';
 import * as PlusMinusRedux from '../ActionsReducers/PlusMinusRedux';
@@ -43,7 +45,6 @@ import * as ToolPanelRedux from '../ActionsReducers/ToolPanelRedux';
 import * as UserInterfaceRedux from '../ActionsReducers/UserInterfaceRedux';
 import { areAdaptableProfileTracksEnabled, getMarker } from '../../devTools';
 import { isAdaptableSharedEntity, isCustomSharedEntity, } from '../../AdaptableState/TeamSharingState';
-import { buildAdaptableStateFunctionConfig } from './buildAdaptableStateFunctionConfig';
 const INIT_STATE = 'INIT_STATE';
 const LOAD_STATE = 'LOAD_STATE';
 const NON_PERSIST_ACTIONS = {
@@ -225,6 +226,7 @@ export class AdaptableStore {
             beforeEmitterMiddleware,
             devToolsActionMarkerMiddleware,
             adaptableMiddleware(adaptable),
+            layoutExtensionsMiddleware,
             ...pluginsMiddleware,
         ].filter(Boolean);
         this.TheStore = Redux.createStore(persistedReducer, composeEnhancers(Redux.applyMiddleware(...middlewares)));
@@ -258,7 +260,7 @@ export class AdaptableStore {
             .load(adaptable, initialState ?? adaptable.adaptableOptions.initialState)
             .then((storedState) => {
             if (storedState && this.loadStateOnStartup) {
-                this.TheStore.dispatch(LoadState(postProcessState(adaptable.adaptableOptions.stateOptions.applyState(storedState, buildAdaptableStateFunctionConfig(adaptable)))));
+                this.TheStore.dispatch(LoadState(postProcessState(adaptable.adaptableOptions.stateOptions.applyState(storedState, adaptable.api.stateApi.internalApi.buildAdaptableStateFunctionConfig()))));
             }
         })
             .then(() => {
@@ -380,6 +382,98 @@ function coerceMarkerDetailValue(value) {
         return '[unserializable]';
     }
 }
+function refreshFormulaTraceCells(adaptable, formulaTraceInfo) {
+    if (!formulaTraceInfo) {
+        return;
+    }
+    const rowNode = adaptable.api.gridApi.getRowNodeForPrimaryKey(formulaTraceInfo.primaryKeyValue);
+    if (rowNode) {
+        adaptable.api.gridApi.refreshCell(rowNode, formulaTraceInfo.calculatedColumnId, true);
+    }
+    if (formulaTraceInfo.isAggregated) {
+        adaptable.refreshHeader();
+        return;
+    }
+    if (!rowNode) {
+        return;
+    }
+    formulaTraceInfo.entries.forEach((entry) => {
+        adaptable.api.gridApi.refreshCell(rowNode, entry.columnId, true);
+    });
+}
+const LAYOUT_EXTENSION_OBJECT_ACTIONS = {
+    [AlertRedux.ALERT_DEFINITION_EDIT]: { module: 'Alert', payloadKey: 'alertDefinition', kind: 'edit' },
+    [AlertRedux.ALERT_DEFINITION_DELETE]: { module: 'Alert', payloadKey: 'alertDefinition', kind: 'delete' },
+    [CustomSortRedux.CUSTOM_SORT_EDIT]: { module: 'CustomSort', payloadKey: 'customSort', kind: 'edit' },
+    [CustomSortRedux.CUSTOM_SORT_DELETE]: { module: 'CustomSort', payloadKey: 'customSort', kind: 'delete' },
+    [FlashingCellRedux.FLASHING_CELL_DEFINITION_EDIT]: {
+        module: 'FlashingCell',
+        payloadKey: 'flashingCellDefinition',
+        kind: 'edit',
+    },
+    [FlashingCellRedux.FLASHING_CELL_DEFINITION_DELETE]: {
+        module: 'FlashingCell',
+        payloadKey: 'flashingCellDefinition',
+        kind: 'delete',
+    },
+    [FormatColumnRedux.FORMAT_COLUMN_EDIT]: { module: 'FormatColumn', payloadKey: 'formatColumn', kind: 'edit' },
+    [FormatColumnRedux.FORMAT_COLUMN_DELETE]: {
+        module: 'FormatColumn',
+        payloadKey: 'formatColumn',
+        kind: 'delete',
+    },
+    [PlusMinusRedux.PLUS_MINUS_RULE_EDIT]: { module: 'PlusMinus', payloadKey: 'plusMinusNudge', kind: 'edit' },
+    [PlusMinusRedux.PLUS_MINUS_RULE_DELETE]: {
+        module: 'PlusMinus',
+        payloadKey: 'plusMinusNudge',
+        kind: 'delete',
+    },
+    [ShortcutRedux.SHORTCUT_EDIT]: { module: 'Shortcut', payloadKey: 'shortcut', kind: 'edit' },
+    [ShortcutRedux.SHORTCUT_DELETE]: { module: 'Shortcut', payloadKey: 'shortcut', kind: 'delete' },
+    [StyledColumnRedux.STYLED_COLUMN_EDIT]: { module: 'StyledColumn', payloadKey: 'StyledColumn', kind: 'edit' },
+    [StyledColumnRedux.STYLED_COLUMN_DELETE]: {
+        module: 'StyledColumn',
+        payloadKey: 'StyledColumn',
+        kind: 'delete',
+    },
+};
+const LAYOUT_EXTENSION_MODULE_CLEAR_ACTIONS = {
+    [FormatColumnRedux.FORMAT_COLUMN_DELETE_ALL]: 'FormatColumn',
+    [StyledColumnRedux.STYLED_COLUMN_DELETE_ALL]: 'StyledColumn',
+};
+function getLayoutExtensionCascadeActions(action, previousState) {
+    if (!hasLayoutExtensions(previousState.Layout?.LayoutExtensions)) {
+        return [];
+    }
+    const clearedModule = LAYOUT_EXTENSION_MODULE_CLEAR_ACTIONS[action.type];
+    if (clearedModule) {
+        return [LayoutRedux.LayoutExtensionsClearModule(clearedModule)];
+    }
+    const config = LAYOUT_EXTENSION_OBJECT_ACTIONS[action.type];
+    const object = config && action[config.payloadKey];
+    if (!object) {
+        return [];
+    }
+    const previousObject = getAllLayoutExtensionObjects(previousState, config.module).find((candidate) => (object.Uuid ? candidate.Uuid === object.Uuid : candidate.Name === object.Name));
+    if (!previousObject?.Name) {
+        return [];
+    }
+    if (config.kind === 'delete') {
+        return [LayoutRedux.LayoutExtensionsDeleteObject(config.module, previousObject.Name)];
+    }
+    if (object.Name && object.Name !== previousObject.Name) {
+        return [
+            LayoutRedux.LayoutExtensionsRenameObject(config.module, previousObject.Name, object.Name),
+        ];
+    }
+    return [];
+}
+const layoutExtensionsMiddleware = (middlewareAPI) => (next) => (action) => {
+    const cascadeActions = getLayoutExtensionCascadeActions(action, middlewareAPI.getState());
+    const result = next(action);
+    cascadeActions.forEach((cascadeAction) => middlewareAPI.dispatch(cascadeAction));
+    return result;
+};
 const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
     return function (next) {
         return function (action) {
@@ -395,14 +489,20 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case NamedQueryRedux.NAMED_QUERY_EDIT: {
                     const actionTyped = action;
                     const editedNamedQuery = actionTyped.namedQuery;
-                    const previousNamedQueryName = middlewareAPI
+                    const previousNamedQuery = middlewareAPI
                         .getState()
-                        .NamedQuery.NamedQueries.find((namedQuery) => namedQuery.Uuid === editedNamedQuery.Uuid)?.Name ?? '';
+                        .NamedQuery.NamedQueries.find((namedQuery) => namedQuery.Uuid === editedNamedQuery.Uuid) ?? undefined;
+                    const previousNamedQueryName = previousNamedQuery?.Name ?? '';
                     if (editedNamedQuery.Name !== previousNamedQueryName) {
                         if (!adaptable.api.namedQueryApi.internalApi.validateRenamedNamedQuery(previousNamedQueryName)) {
                             return;
                         }
                     }
+                    const previousReturnType = previousNamedQuery?.ReturnType ?? 'boolean';
+                    const nextReturnType = editedNamedQuery.ReturnType ?? 'boolean';
+                    if (!adaptable.api.namedQueryApi.internalApi.validateNamedQueryReturnTypeChange(previousNamedQueryName || editedNamedQuery.Name, previousReturnType, nextReturnType)) {
+                        return;
+                    }
                     const ret = next(action);
                     return ret;
                 }
@@ -430,39 +530,29 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case AlertRedux.ALERT_DEFINITION_SUSPEND_ALL: {
                     const returnAction = next(action);
                     const alertDefinition = returnAction.alertDefinition;
-                    if (alertDefinition) {
-                        if (!isScheduledAlertDefinition(alertDefinition) &&
-                            (returnAction.type === AlertRedux.ALERT_DEFINITION_ADD ||
-                                returnAction.type === AlertRedux.ALERT_DEFINITION_EDIT ||
-                                returnAction.type === AlertRedux.ALERT_DEFINITION_UNSUSPEND)) {
-                            adaptable.api.internalApi.getAlertService().createReactiveAlert(alertDefinition);
+                    const liveBindings = adaptable.api.internalApi.getAlertLiveBindingService();
+                    if (alertDefinition &&
+                        !isScheduledAlertDefinition(alertDefinition) &&
+                        !isRowChangeAlertDefinition(alertDefinition)) {
+                        if (returnAction.type === AlertRedux.ALERT_DEFINITION_ADD ||
+                            returnAction.type === AlertRedux.ALERT_DEFINITION_EDIT ||
+                            returnAction.type === AlertRedux.ALERT_DEFINITION_UNSUSPEND) {
+                            const ruleClass = adaptable.api.alertApi.internalApi.classifyRule(alertDefinition);
+                            if (ruleClass === 'live') {
+                                liveBindings.bind(alertDefinition);
+                            }
+                            else {
+                                liveBindings.unbind(alertDefinition.Uuid);
+                            }
                         }
-                        if (!isScheduledAlertDefinition(alertDefinition) &&
-                            (returnAction.type === AlertRedux.ALERT_DEFINITION_DELETE ||
-                                returnAction.type === AlertRedux.ALERT_DEFINITION_SUSPEND)) {
-                            adaptable.api.internalApi.getAlertService().deleteReactiveAlert(alertDefinition);
+                        if (returnAction.type === AlertRedux.ALERT_DEFINITION_DELETE ||
+                            returnAction.type === AlertRedux.ALERT_DEFINITION_SUSPEND) {
+                            liveBindings.unbind(alertDefinition.Uuid);
                         }
                     }
-                    if (returnAction.type === AlertRedux.ALERT_DEFINITION_SUSPEND_ALL) {
-                        adaptable.api.internalApi
-                            .getAlertService()
-                            .getReactiveActiveAlerts()
-                            .forEach((alertDefinition) => {
-                            adaptable.api.internalApi.getAlertService().deleteReactiveAlert(alertDefinition);
-                        });
-                    }
-                    if (returnAction.type === AlertRedux.ALERT_DEFINITION_UNSUSPEND_ALL) {
-                        adaptable.api.alertApi.internalApi
-                            .getReactiveAlertDefinitions()
-                            .forEach((alertDefinition) => {
-                            if (!adaptable.api.internalApi
-                                .getAlertService()
-                                .isReactiveAlertActive(alertDefinition)) {
-                                adaptable.api.internalApi
-                                    .getAlertService()
-                                    .createReactiveAlert(alertDefinition);
-                            }
-                        });
+                    if (returnAction.type === AlertRedux.ALERT_DEFINITION_SUSPEND_ALL ||
+                        returnAction.type === AlertRedux.ALERT_DEFINITION_UNSUSPEND_ALL) {
+                        liveBindings.syncFromState();
                     }
                     adaptable.updateColumnModelAndRefreshGrid({ rows: true });
                     let module = (adaptable.adaptableModules.get(ModuleConstants.AlertModuleId));
@@ -495,6 +585,10 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                         if (!adaptable.api.freeTextColumnApi.internalApi.validateDeletedFreeTextColumn(actionTyped.freeTextColumn)) {
                             return;
                         }
+                        if (adaptable.api.optionsApi.getLayoutOptions()
+                            ?.autoRemoveDeletedColumnsFromLayouts !== false) {
+                            adaptable.api.layoutApi.internalApi.removeColumnIdFromAllLayouts(actionTyped.freeTextColumn.ColumnId);
+                        }
                     }
                     const returnAction = next(action);
                     let module = (adaptable.adaptableModules.get(ModuleConstants.FreeTextColumnModuleId));
@@ -513,18 +607,22 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                         if (!adaptable.api.calculatedColumnApi.internalApi.validateDeletedCalculatedColumn(calculatedColumn)) {
                             return;
                         }
+                        if (adaptable.api.optionsApi.getLayoutOptions()
+                            ?.autoRemoveDeletedColumnsFromLayouts !== false) {
+                            adaptable.api.layoutApi.internalApi.removeColumnIdFromAllLayouts(calculatedColumn.ColumnId);
+                        }
                     }
                     const returnAction = next(action);
                     if (action.type === CalculatedColumnRedux.CALCULATED_COLUMN_ADD ||
                         action.type === CalculatedColumnRedux.CALCULATED_COLUMN_EDIT) {
                         adaptable.api.internalApi
                             .getCalculatedColumnExpressionService()
-                            .createAggregatedScalarLiveValue(calculatedColumn);
+                            .bindAggregatedCalculatedColumn(calculatedColumn);
                     }
                     else {
                         adaptable.api.internalApi
                             .getCalculatedColumnExpressionService()
-                            .destroyAggregatedScalarLiveValue(calculatedColumn);
+                            .unbindAggregatedCalculatedColumn(calculatedColumn);
                     }
                     adaptable.api.eventApi.internalApi.fireCalculatedColumnChangedEvent(action.type, calculatedColumn);
                     let module = (adaptable.adaptableModules.get(ModuleConstants.CalculatedColumnModuleId));
@@ -532,6 +630,10 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                         module.checkListenToCellDataChanged();
                     }
                     adaptable.api.layoutApi.internalApi.refreshLayout();
+                    adaptable.api.internalApi.getLiveRefreshService().syncFromState();
+                    if (action.type === CalculatedColumnRedux.CALCULATED_COLUMN_EDIT) {
+                        adaptable.api.calculatedColumnApi.internalApi.syncFormulaTraceWithCalculatedColumn(calculatedColumn);
+                    }
                     return returnAction;
                 }
                 case QuickSearchRedux.QUICK_SEARCH_SET_CELL_MATCHING_STYLE:
@@ -563,6 +665,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                         cells: true,
                         header: hadHeaderFormatColumns || hasHeaderFormatColumns,
                     });
+                    adaptable.api.internalApi.getLiveRefreshService().syncFromState();
                     return returnAction;
                 }
                 case StyledColumnRedux.STYLED_COLUMN_ADD:
@@ -574,6 +677,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case StyledColumnRedux.STYLED_COLUMN_UNSUSPEND_ALL: {
                     const returnAction = next(action);
                     adaptable.updateColumnModelAndRefreshGrid({ cells: true });
+                    adaptable.api.internalApi.getLiveRefreshService().syncFromState();
                     return returnAction;
                 }
                 case CustomSortRedux.CUSTOM_SORT_ADD:
@@ -699,6 +803,25 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     });
                     return ret;
                 }
+                case InternalRedux.FORMULA_TRACE_SHOW: {
+                    const previous = middlewareAPI.getState().Internal.FormulaTraceInfo;
+                    const ret = next(action);
+                    const actionTyped = action;
+                    refreshFormulaTraceCells(adaptable, previous);
+                    refreshFormulaTraceCells(adaptable, actionTyped.formulaTraceInfo);
+                    return ret;
+                }
+                case InternalRedux.FORMULA_TRACE_HIDE: {
+                    const previous = middlewareAPI.getState().Internal.FormulaTraceInfo;
+                    const ret = next(action);
+                    refreshFormulaTraceCells(adaptable, previous);
+                    return ret;
+                }
+                case InternalRedux.COMPACT_CALCULATED_COLUMN_EDITOR_HIDE: {
+                    const ret = next(action);
+                    adaptable.api.calculatedColumnApi.internalApi.hideFormulaTrace();
+                    return ret;
+                }
                 case InternalRedux.HIGHLIGHT_COLUMN_ADD: {
                     const actionTyped = action;
                     const ret = next(action);
@@ -813,9 +936,15 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case NoteRedux.NOTE_EDIT:
                 case NoteRedux.NOTE_DELETE: {
                     let returnAction = next(action);
-                    adaptable.AnnotationsService.checkListenToEvents();
+                    adaptable.CommentsService.checkListenToEvents();
                     const rowNode = adaptable.api.gridApi.getRowNodeForPrimaryKey(returnAction.adaptableNote.PrimaryKeyValue);
-                    adaptable.api.gridApi.refreshCell(rowNode, returnAction.adaptableNote.ColumnId, true);
+                    adaptable.api.agGridApi.refreshNotes?.({
+                        rowNodes: rowNode ? [rowNode] : undefined,
+                        columns: [returnAction.adaptableNote.ColumnId],
+                    });
+                    if (rowNode) {
+                        adaptable.refreshCells(rowNode, [returnAction.adaptableNote.ColumnId], true, true);
+                    }
                     return returnAction;
                 }
                 case CommentsRedux.COMMENT_ADD:
@@ -824,7 +953,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case CommentsRedux.COMMENT_THREAD_DELETE:
                 case CommentsRedux.COMMENT_THREAD_ADD: {
                     let returnAction = next(action);
-                    adaptable.AnnotationsService.checkListenToEvents();
+                    adaptable.CommentsService.checkListenToEvents();
                     let rowNode = null;
                     let columnId = null;
                     if ('cellAddress' in returnAction) {
@@ -917,6 +1046,17 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     adaptable.api.eventApi.internalApi.fireDashboardChangedEvent(action.type, oldDashboardState, newDashboardState);
                     return returnAction;
                 }
+                case LayoutRedux.LAYOUT_EXTENSIONS_SET:
+                case LayoutRedux.LAYOUT_EXTENSION_OBJECT_ADD:
+                case LayoutRedux.LAYOUT_EXTENSION_OBJECT_REMOVE:
+                case LayoutRedux.LAYOUT_EXTENSION_OBJECT_LAYOUTS_SET: {
+                    const oldLayoutExtensions = middlewareAPI.getState().Layout.LayoutExtensions;
+                    const returnAction = next(action);
+                    if (middlewareAPI.getState().Layout.LayoutExtensions !== oldLayoutExtensions) {
+                        adaptable.adaptableModules.get(ModuleConstants.LayoutModuleId)?.refreshLayoutExtensionObjects();
+                    }
+                    return returnAction;
+                }
                 case LayoutRedux.LAYOUT_ADD:
                 case LayoutRedux.LAYOUT_EDIT:
                 case LayoutRedux.LAYOUT_SAVE:
@@ -945,6 +1085,10 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     if (adaptable.api.filterApi.gridFilterApi.internalApi.isGridFilterDifferent(oldLayout.GridFilter, newLayout.GridFilter)) {
                         refreshGridFilter = true;
                     }
+                    if (refreshColumnFilters) {
+                        adaptable.clearColumnFiltering();
+                        middlewareAPI.dispatch(InternalRedux.ColumnFilterDraftClearAll());
+                    }
                     if (refreshColumnFilters || refreshGridFilter) {
                         adaptable.applyFiltering({ updateColumnFilterModel: refreshColumnFilters });
                     }
@@ -977,7 +1121,24 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                             adaptable.applyFiltering();
                         }, 50);
                     }
-                    adaptable.api.eventApi.internalApi.fireColumnFilterAppliedEvent();
+                    const columnFilterAction = action;
+                    const columnId = columnFilterAction.columnFilter?.ColumnId ?? columnFilterAction.columnId;
+                    const expression = columnFilterAction.columnFilter?.Expression;
+                    let isComplete = Boolean(expression);
+                    if (action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_CLEAR ||
+                        action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_CLEAR_ALL) {
+                        isComplete = false;
+                    }
+                    else if (action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_SUSPEND_ALL ||
+                        action.type === LayoutRedux.LAYOUT_COLUMN_FILTER_UNSUSPEND_ALL) {
+                        isComplete = Boolean(adaptable.api.filterApi.columnFilterApi.getColumnFilters()?.length);
+                    }
+                    adaptable.api.eventApi.internalApi.fireColumnFilterChangedEvent({
+                        columnId,
+                        isApplied: true,
+                        isComplete,
+                        expression,
+                    });
                     adaptable.api.eventApi.internalApi.fireLayoutChangedEvent(action.type, oldLayoutState, middlewareAPI.getState().Layout);
                     return returnAction;
                 }
@@ -985,9 +1146,10 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case LayoutRedux.LAYOUT_GRID_FILTER_CLEAR:
                 case LayoutRedux.LAYOUT_GRID_FILTER_SUSPEND:
                 case LayoutRedux.LAYOUT_GRID_FILTER_UNSUSPEND: {
+                    const oldLayoutState = middlewareAPI.getState().Layout;
                     let returnAction = next(action);
                     adaptable.api.eventApi.internalApi.fireGridFilterAppliedEvent();
-                    adaptable.api.eventApi.internalApi.fireLayoutChangedEvent(action.type, null, middlewareAPI.getState().Layout);
+                    adaptable.api.eventApi.internalApi.fireLayoutChangedEvent(action.type, oldLayoutState, middlewareAPI.getState().Layout);
                     setTimeout(() => {
                         adaptable.applyFiltering({ updateColumnFilterModel: false });
                     }, 5);
@@ -1001,14 +1163,10 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     let popup = state.Popup.ScreenPopup;
                     if (popup.ComponentName != 'LayoutPopup') {
                         if (apiReturn.Alert) {
-                            if (popup.ComponentName == 'SmartEditPopup') {
-                                adaptable.api.internalApi.hidePopupScreen();
-                                adaptable.api.alertApi.displayAdaptableAlertNotification(apiReturn.Alert);
-                            }
-                            middlewareAPI.dispatch(InternalRedux.SmartEditSetValidSelection(false));
+                            middlewareAPI.dispatch(InternalRedux.SmartEditSetValidSelection(false, apiReturn.Alert));
                         }
                         else {
-                            middlewareAPI.dispatch(InternalRedux.SmartEditSetValidSelection(true));
+                            middlewareAPI.dispatch(InternalRedux.SmartEditSetValidSelection(true, null));
                             let apiPreviewReturn = module.BuildPreviewValues(state.Internal.SmartEdit.SmartEditValue, state.Internal.SmartEdit.SmartEditOperation);
                             middlewareAPI.dispatch(InternalRedux.SmartEditSetPreview(apiPreviewReturn));
                         }
@@ -1040,12 +1198,6 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     let apiReturn = module.checkCorrectCellSelection();
                     let popup = state.Popup.ScreenPopup;
                     if (popup.ComponentName != 'LayoutPopup') {
-                        if (apiReturn.Alert) {
-                            if (popup.ComponentName == 'BulkUpdatePopup') {
-                                adaptable.api.internalApi.hidePopupScreen();
-                                adaptable.api.alertApi.displayAdaptableAlertNotification(apiReturn.Alert);
-                            }
-                        }
                         middlewareAPI.dispatch(InternalRedux.BulkUpdateSetValidSelection(apiReturn));
                     }
                     return returnAction;
@@ -1133,6 +1285,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                         .loadSharedEntities()
                         .then((sharedEntities) => {
                         middlewareAPI.dispatch(TeamSharingRedux.TeamSharingSet(sharedEntities));
+                        adaptable.api.teamSharingApi.internalApi.persistMigratedSharedEntitiesIfNeeded(sharedEntities);
                     })
                         .catch((error) => {
                         adaptable.api.logError('TeamSharing get error : ' + error.message);
@@ -1322,6 +1475,10 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                             adaptable.api.logError('Team Sharing Import Error: Unknown item type', sharedEntity);
                         }
                     }
+                    adaptable.api.internalApi
+                        .getTeamSharingService()
+                        .buildLayoutExtensionImportActions(ImportSteps)
+                        .forEach((layoutExtensionAction) => middlewareAPI.dispatch(layoutExtensionAction));
                     if (activeSharedEntities.length) {
                         middlewareAPI.dispatch(TeamSharingRedux.TeamSharingLinkItem(...activeSharedEntities));
                     }

package/src/Strategy/AdaptableModuleBase.d.ts

@@ -1,5 +1,5 @@
 import { AgModuleName } from 'ag-grid-enterprise';
-import { IModule, ModuleInfo, TeamSharingReferences } from './Interface/IModule';
+import { IModule, ModuleAdaptableObjectsConfig, ModuleInfo, TeamSharingReferences } from './Interface/IModule';
 import { Action } from 'redux';
 import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
 import { ModuleParams } from '../View/Components/SharedProps/ModuleViewPopupProps';
@@ -12,8 +12,9 @@ import { AdaptableApi } from '../Api/AdaptableApi';
 import { AccessLevel } from '../AdaptableState/Common/Entitlement';
 import { CalculatedColumn } from '../AdaptableState/CalculatedColumnState';
 import { FreeTextColumn } from '../AdaptableState/FreeTextColumnState';
-import { AdaptableSystemIconName } from '../AdaptableState/Common/AdaptableIcon';
+import { AdaptableIcon, AdaptableSystemIconName } from '../AdaptableState/Common/AdaptableIcon';
 import { AdaptableStateReloadedInfo } from '../Api/Events/AdaptableStateReloaded';
+import { LayoutExtensionModule, LayoutExtensionObject } from '../types';
 /**
  * Base class for all strategies and does most of the work of creating menus
  */
@@ -31,6 +32,12 @@ export declare abstract class AdaptableModuleBase implements IModule {
     protected getAgGridModuleDependencies(): AgModuleName[];
     isModuleEnabled(): boolean;
     isModuleAvailable(): boolean;
+    /**
+     * Default AccessLevel when the user has not set an explicit module entitlement.
+     * Uses `entitlementOptions.defaultAccessLevel` (value or function), else `Full`.
+     * Override in subclasses for opt-in modules (e.g. State Management → Hidden).
+     */
+    getDefaultAccessLevel(): AccessLevel;
     isModuleVisible(): boolean;
     isModuleEditable(): boolean;
     setAgGridDepsInfo(): void;
@@ -40,7 +47,11 @@ export declare abstract class AdaptableModuleBase implements IModule {
      * Used inside the unified UI to show the share button
      */
     isModuleObjectsShareable(): boolean;
-    getModuleAdaptableObjects(): AdaptableObject[];
+    getModuleAdaptableObjects(_config?: ModuleAdaptableObjectsConfig): AdaptableObject[];
+    /**
+     * For Layout Extension Modules: objects applying in the Current Layout, or every object when `includeAllLayouts` is set
+     */
+    protected getLayoutExtensionModuleObjects<T extends LayoutExtensionObject>(module: LayoutExtensionModule, getCurrentLayoutObjects: () => T[], config?: ModuleAdaptableObjectsConfig): T[];
     getExplicitlyReferencedColumnIds(adaptableObject: AdaptableObject): string[];
     getReferencedNamedQueryNames(adaptableObject: AdaptableObject): string[];
     hasNamedQueryReferences(): boolean;
@@ -54,12 +65,12 @@ export declare abstract class AdaptableModuleBase implements IModule {
         Name: MENU_TYPE_NAME;
         Label: string;
         ComponentName: string;
-        Icon: AdaptableSystemIconName;
+        Icon: AdaptableSystemIconName | AdaptableIcon;
         PopupParams?: ModuleParams;
     }): MenuItemShowPopup<MENU_TYPE_NAME>;
-    createMenuItemClickFunction<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName>(Name: MENU_TYPE_NAME, Label: string, Icon: AdaptableSystemIconName, ClickFunction: () => void): MenuItemDoClickFunction<MENU_TYPE_NAME>;
-    createMenuItemReduxAction<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName>(Name: MENU_TYPE_NAME, Label: string, Icon: AdaptableSystemIconName, Action: Action): MenuItemDoReduxAction<MENU_TYPE_NAME>;
-    createMenuItemShowPopup<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName>(Name: MENU_TYPE_NAME, Label: string, ComponentName: string, Icon: AdaptableSystemIconName, PopupParams?: ModuleParams): MenuItemShowPopup<MENU_TYPE_NAME>;
+    createMenuItemClickFunction<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName>(Name: MENU_TYPE_NAME, Label: string, Icon: AdaptableSystemIconName | AdaptableIcon, ClickFunction: () => void): MenuItemDoClickFunction<MENU_TYPE_NAME>;
+    createMenuItemReduxAction<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName>(Name: MENU_TYPE_NAME, Label: string, Icon: AdaptableSystemIconName | AdaptableIcon, Action: Action): MenuItemDoReduxAction<MENU_TYPE_NAME>;
+    createMenuItemShowPopup<MENU_TYPE_NAME extends AdaptableColumnMenuItemName | AdaptableContextMenuItemName = AdaptableColumnMenuItemName | AdaptableContextMenuItemName>(Name: MENU_TYPE_NAME, Label: string, ComponentName: string, Icon: AdaptableSystemIconName | AdaptableIcon, PopupParams?: ModuleParams): MenuItemShowPopup<MENU_TYPE_NAME>;
     getTeamSharingAction(): TeamSharingImportInfo<AdaptableObject> | undefined;
     getModuleNamedQueryReferences(): string[];
     getModuleCalculatedColumnReferences(): CalculatedColumn[];
@@ -72,5 +83,6 @@ export declare abstract class AdaptableModuleBase implements IModule {
     containsLayoutExtensions(): boolean;
     showLayoutNonExtendedObjects(): boolean;
     private getFriendlyName;
+    private getGlyph;
     private hasRequiredAccessLevel;
 }

package/src/Strategy/AdaptableModuleBase.js

@@ -1,5 +1,6 @@
 import { MenuItemShowPopup, MenuItemDoReduxAction, MenuItemDoClickFunction, } from '../AdaptableState/Common/MenuItem';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
+import { isLayoutExtensionModule } from '../Utilities/Helpers/Layouts/LayoutExtensionHelper';
 import { ACCESS_LEVEL_FULL, ACCESS_LEVEL_HIDDEN, ACCESS_LEVEL_READ_ONLY, } from '../Utilities/Constants/GeneralConstants';
 export class AdaptableModuleBase {
     api;
@@ -15,7 +16,7 @@ export class AdaptableModuleBase {
             FriendlyName: this.getFriendlyName(module, friendlyName),
             Description: description,
             HelpPage: this.api.internalApi.getModuleService().getModuleDocumentationPageByModule(module),
-            Glyph: glyph,
+            Glyph: this.getGlyph(module, glyph),
             Popup: popup,
         };
         this.api = api;
@@ -42,6 +43,16 @@ export class AdaptableModuleBase {
     isModuleAvailable() {
         return this.agGridModuleDepsInfo?.hasRequiredAgGridModuleDependencies;
     }
+    getDefaultAccessLevel() {
+        const entitlementOptions = this.api.optionsApi.getEntitlementOptions();
+        if (!entitlementOptions) {
+            return ACCESS_LEVEL_FULL;
+        }
+        if (typeof entitlementOptions.defaultAccessLevel === 'function') {
+            return entitlementOptions.defaultAccessLevel(this.api.internalApi.buildBaseContext());
+        }
+        return entitlementOptions.defaultAccessLevel ?? ACCESS_LEVEL_FULL;
+    }
     isModuleVisible() {
         return (this.isModuleEnabled() &&
             this.isModuleAvailable() &&
@@ -77,9 +88,14 @@ export class AdaptableModuleBase {
     isModuleObjectsShareable() {
         return true;
     }
-    getModuleAdaptableObjects() {
+    getModuleAdaptableObjects(_config) {
         return [];
     }
+    getLayoutExtensionModuleObjects(module, getCurrentLayoutObjects, config) {
+        return config?.includeAllLayouts
+            ? this.api.layoutApi.internalApi.getAllLayoutExtensionObjects(module)
+            : getCurrentLayoutObjects();
+    }
     getExplicitlyReferencedColumnIds(adaptableObject) {
         return [];
     }
@@ -137,13 +153,13 @@ export class AdaptableModuleBase {
             return [];
         }
         const references = [];
-        this.getModuleAdaptableObjects().forEach((adaptableObject) => references.push(...this.getReferencedNamedQueryNames(adaptableObject)));
+        this.getModuleAdaptableObjects({ includeAllLayouts: true }).forEach((adaptableObject) => references.push(...this.getReferencedNamedQueryNames(adaptableObject)));
         return references;
     }
     getModuleCalculatedColumnReferences() {
         const references = [];
         const allCalculatedColumns = this.api.calculatedColumnApi.getCalculatedColumns();
-        this.getModuleAdaptableObjects().forEach((adaptableObject) => {
+        this.getModuleAdaptableObjects({ includeAllLayouts: true }).forEach((adaptableObject) => {
             const referencedColumnIds = this.getExplicitlyReferencedColumnIds(adaptableObject);
             referencedColumnIds.forEach((referencedColumnId) => {
                 const referencedCalculatedColumn = allCalculatedColumns.find((calculatedColumn) => calculatedColumn.ColumnId === referencedColumnId);
@@ -157,7 +173,7 @@ export class AdaptableModuleBase {
     getModuleFreeTextColumnReferences() {
         const references = [];
         const allFreeTextColumns = this.api.freeTextColumnApi.getFreeTextColumns();
-        this.getModuleAdaptableObjects().forEach((adaptableObject) => {
+        this.getModuleAdaptableObjects({ includeAllLayouts: true }).forEach((adaptableObject) => {
             const referencedColumnIds = this.getExplicitlyReferencedColumnIds(adaptableObject);
             referencedColumnIds.forEach((referencedColumnId) => {
                 const referencedFreeTextColumn = allFreeTextColumns.find((freeTextColumn) => freeTextColumn.ColumnId === referencedColumnId);
@@ -205,7 +221,7 @@ export class AdaptableModuleBase {
         return undefined;
     }
     containsLayoutExtensions() {
-        return false;
+        return isLayoutExtensionModule(this.moduleInfo.ModuleName);
     }
     showLayoutNonExtendedObjects() {
         return this.api.layoutApi.internalApi.showLayoutNonExtendedObjects();
@@ -223,6 +239,17 @@ export class AdaptableModuleBase {
         }
         return returnValue;
     }
+    getGlyph(module, glyph) {
+        const userInterfaceOptions = this.api.optionsApi.getUserInterfaceOptions();
+        if (userInterfaceOptions &&
+            ArrayExtensions.IsNotNullOrEmpty(userInterfaceOptions.alternativeModuleIcons)) {
+            const alternative = userInterfaceOptions.alternativeModuleIcons.find((ai) => ai.adaptableModule === module);
+            if (alternative?.newIcon) {
+                return alternative.newIcon;
+            }
+        }
+        return { name: glyph };
+    }
     hasRequiredAccessLevel(requiredAccessLevel) {
         if (this.AccessLevel === ACCESS_LEVEL_HIDDEN) {
             return false;