@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

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

@@ -1,26 +1,19 @@
 import { AdaptableApi, TableLayout } from '../../types';
-import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
 /**
- * The logic is extracted here to make it easier to follow
+ * Row Summary cells are computed-value store nodes with an explicit
+ * rowSetSpec (`visible` when IncludeOnlyFilteredRows, else `all`).
+ * Store batching replaces the old 300ms throttle and `setTimeout(16)`.
  */
 export declare class RowSummaryService {
     private api;
-    cachedCellSummary: Map<string, AggregatedScalarLiveValue>;
+    private nodeHandles;
+    private isEvaluating;
     previousRowSummaries: any;
     previousLayout: TableLayout | null;
     constructor(api: AdaptableApi);
     onAdaptableReady(): void;
     rowSummariesSubscriptions(): void;
-    _throttleAcumulatedColumnsThatChanged: Set<string>;
-    throttledEvaluateRowSummary(reason?: {
-        columnIds: string[];
-    }): void;
-    /**
-     *
-     * @param colId optional to evaluate only one column
-     */
-    _throttledEvaluateRowSummary: import("../Helpers/TimingHelper").DebouncedFunction<(reason?: {
-        columnIds: string[];
-    }) => void>;
+    destroy(): void;
     private evaluateRowSummary;
+    private evaluateRowSummaryUnguarded;
 }

package/src/Utilities/Services/RowSummaryService.js

@@ -2,13 +2,12 @@ import { ROW_SUMMARY_ROW_ID, WEIGHTED_AVERAGE_AGGREGATED_FUNCTION, } from '../..
 import { RowSummarySet } from '../../Redux/ActionsReducers/InternalRedux';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import { roundNumber } from '../Extensions/NumberExtensions';
-import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
 import { isObjectEmpty } from '../Extensions/ObjectExtensions';
-import { throttle } from '../Helpers/TimingHelper';
 import { isEqual } from '../Extensions/ObjectExtensions';
 export class RowSummaryService {
     api;
-    cachedCellSummary = new Map();
+    nodeHandles = new Map();
+    isEvaluating = false;
     previousRowSummaries;
     previousLayout;
     constructor(api) {
@@ -24,58 +23,54 @@ export class RowSummaryService {
         if (!this.api.layoutApi.internalApi.getLayoutSupportedFeatures().RowSummaries) {
             return;
         }
-        this.throttledEvaluateRowSummary();
+        this.evaluateRowSummary();
         this.api.eventApi.on('AdaptableStateReloaded', () => {
-            this.throttledEvaluateRowSummary();
-        });
-        this.api.internalApi
-            .getDataService()
-            .on('RowDataChanged', (rowDataChangedInfo) => {
-            this.throttledEvaluateRowSummary();
-        });
-        this.api.eventApi.on('CellChanged', (event) => {
-            const columnId = event.cellDataChange.column.columnId;
-            this.throttledEvaluateRowSummary({
-                columnIds: [columnId],
-            });
+            this.evaluateRowSummary();
         });
         this.api.eventApi.on('LayoutChanged', (event) => {
             if (event.actionName.includes('FILTER')) {
                 return;
             }
-            setTimeout(() => {
-                this.throttledEvaluateRowSummary();
-            }, 16);
+            this.api.internalApi.getQueryLanguageService().getComputedValueStore().markAllDirty();
+            this.evaluateRowSummary();
         });
         const adaptable = this.api.internalApi.getAdaptableInstance();
         adaptable._on('AdapTableFiltersApplied', () => {
-            this.throttledEvaluateRowSummary();
+            this.api.internalApi.getQueryLanguageService().getComputedValueStore().markAllDirty();
+            this.evaluateRowSummary();
         });
         adaptable._on('FirstDataRendered', () => {
-            this.throttledEvaluateRowSummary();
+            this.evaluateRowSummary();
         });
     }
-    _throttleAcumulatedColumnsThatChanged = new Set();
-    throttledEvaluateRowSummary(reason) {
-        if (reason) {
-            reason.columnIds.forEach((col) => this._throttleAcumulatedColumnsThatChanged.add(col));
-        }
-        this._throttledEvaluateRowSummary(reason);
+    destroy() {
+        this.nodeHandles.forEach((binding) => {
+            binding.unsubscribe();
+            binding.handle.release();
+        });
+        this.nodeHandles.clear();
     }
-    _throttledEvaluateRowSummary = throttle(this.evaluateRowSummary, 300);
-    evaluateRowSummary(reason) {
-        if (this._throttleAcumulatedColumnsThatChanged.size > 0) {
-            const columnIds = Array.from(this._throttleAcumulatedColumnsThatChanged.values());
-            reason = {
-                columnIds,
-            };
-            this._throttleAcumulatedColumnsThatChanged.clear();
+    evaluateRowSummary() {
+        if (this.isEvaluating) {
+            return;
         }
+        if (this.api.isDestroyed() || this.api.layoutApi.isCurrentLayoutPivot()) {
+            return;
+        }
+        this.isEvaluating = true;
+        try {
+            this.evaluateRowSummaryUnguarded();
+        }
+        finally {
+            this.isEvaluating = false;
+        }
+    }
+    evaluateRowSummaryUnguarded() {
         if (this.api.isDestroyed() || this.api.layoutApi.isCurrentLayoutPivot()) {
             return;
         }
         const currentLayout = this.api.layoutApi.getCurrentLayout();
-        let previousLayout = this.previousLayout;
+        const previousLayout = this.previousLayout;
         this.previousLayout = currentLayout;
         if (isObjectEmpty(currentLayout?.RowSummaries) && isObjectEmpty(previousLayout?.RowSummaries)) {
             return;
@@ -85,56 +80,50 @@ export class RowSummaryService {
             acc[ColumnId] = AggFunc;
             return acc;
         }, {});
+        const liveKeys = new Set();
+        const store = this.api.internalApi.getQueryLanguageService().getComputedValueStore();
         const rowSummariesResults = rowSummaries
             .filter((rowSummary) => !rowSummary.IsSuspended)
             .map((rowSummary, index) => {
-            const { ColumnsMap, Position, IncludeOnlyFilteredRows = true, } = rowSummary;
+            const { ColumnsMap, Position, IncludeOnlyFilteredRows = true } = rowSummary;
+            const rowSetSpec = IncludeOnlyFilteredRows ? 'visible' : 'all';
             return {
                 Position,
                 RowData: Object.entries(ColumnsMap ?? {}).reduce((acc, [columnId, expression]) => {
                     if (columnId === 'Uuid' || columnId === 'Source' || columnId === 'AdaptableVersion') {
                         return acc;
                     }
-                    const key = `${columnId}-${expression}-IncludeOnlyFilteredRows=${IncludeOnlyFilteredRows ? 'filtered' : 'all'}`;
-                    let expressionLiveValue = this.cachedCellSummary.get(key);
-                    if (expressionLiveValue) {
-                        if (!reason) {
-                            expressionLiveValue.refresh();
-                        }
-                        else if ('columnIds' in reason && reason.columnIds.includes(columnId)) {
-                            expressionLiveValue.refresh();
+                    let aggregatedScalarExpression = `${expression}{[${columnId}]}`;
+                    if (aggregatedScalarExpression.includes(WEIGHTED_AVERAGE_AGGREGATED_FUNCTION) &&
+                        aggColsMap[columnId] &&
+                        typeof aggColsMap[columnId] === 'object') {
+                        const weight = aggColsMap[columnId].weightedColumnId;
+                        if (weight) {
+                            aggregatedScalarExpression = `AVG{[${columnId}], WEIGHT([${weight}])}`;
                         }
                     }
-                    if (!expressionLiveValue) {
+                    const key = `${aggregatedScalarExpression}\0${rowSetSpec}`;
+                    liveKeys.add(key);
+                    let binding = this.nodeHandles.get(key);
+                    if (!binding) {
                         try {
-                            let aggregatedScalarExpression = `${expression}([${columnId}])`;
-                            if (aggregatedScalarExpression.includes(WEIGHTED_AVERAGE_AGGREGATED_FUNCTION) &&
-                                aggColsMap[columnId] &&
-                                typeof aggColsMap[columnId] === 'object') {
-                                const weight = aggColsMap[columnId].weightedColumnId;
-                                if (weight) {
-                                    aggregatedScalarExpression = `AVG([${columnId}], WEIGHT([${weight}]))`;
-                                }
-                            }
-                            expressionLiveValue = new AggregatedScalarLiveValue({
-                                aggregatedScalarExpression,
-                            }, ModuleConstants.LayoutModuleId, this.api, () => {
-                                if (rowSummary.IncludeOnlyFilteredRows ?? true) {
-                                    return this.api.gridApi.getVisibleRowNodes();
-                                }
-                                else {
-                                    return this.api.gridApi.getAllRowNodes();
-                                }
+                            const handle = store.getOrCreateNode({
+                                module: ModuleConstants.LayoutModuleId,
+                                expression: aggregatedScalarExpression,
+                                rowSetSpec,
                             });
+                            void handle.node.result;
+                            const unsubscribe = handle.subscribe(() => this.evaluateRowSummary());
+                            binding = { handle, unsubscribe };
+                            this.nodeHandles.set(key, binding);
                         }
                         catch (e) {
                             this.api.logError('Error evaluating row summary', e);
                         }
-                        this.cachedCellSummary.set(key, expressionLiveValue);
                     }
                     let value = null;
-                    if (expressionLiveValue) {
-                        value = expressionLiveValue.getGlobalAggregatedValue();
+                    if (binding) {
+                        value = binding.handle.node.result?.value ?? null;
                         if (typeof value === 'number' && !isNaN(value)) {
                             value = roundNumber(value, 2);
                         }
@@ -148,6 +137,13 @@ export class RowSummaryService {
                 }),
             };
         });
+        for (const [key, binding] of this.nodeHandles) {
+            if (!liveKeys.has(key)) {
+                binding.unsubscribe();
+                binding.handle.release();
+                this.nodeHandles.delete(key);
+            }
+        }
         if (this.previousRowSummaries && isEqual(rowSummariesResults, this.previousRowSummaries)) {
             return;
         }

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

@@ -3,6 +3,7 @@ import { AdaptableModule } from '../../AdaptableState/Common/Types';
 import { AdaptableObject } from '../../AdaptableState/Common/AdaptableObject';
 import { AdaptableSharedEntityConfig, SharedEntityActiveStatus, TeamSharingImportStep, AdaptableSharedEntity, CustomSharedEntity, CustomSharedEntityConfig } from '../../AdaptableState/TeamSharingState';
 import { TypeUuid } from '../../AdaptableState/Uuid';
+import * as Redux from 'redux';
 import { AdaptableApi } from '../../../types';
 export declare class TeamSharingService implements ITeamSharingService {
     private adaptableApi;
@@ -14,6 +15,9 @@ export declare class TeamSharingService implements ITeamSharingService {
     getSharedEntityDependants(sharedEntityId: TypeUuid, sharedEntities: AdaptableSharedEntity[]): AdaptableSharedEntity[];
     updateActiveSharedEntity(changedAdaptableObject: AdaptableObject, userName: string, sharedEntities: AdaptableSharedEntity[]): [AdaptableSharedEntity[], AdaptableSharedEntity[]];
     buildSharedEntityImportActions(importedSharedEntity: AdaptableSharedEntity): [TeamSharingImportStep[], boolean];
+    buildLayoutExtensionImportActions(importSteps: TeamSharingImportStep[]): Redux.Action[];
+    private getLayoutExtensionInfoFromTags;
+    private setLayoutExtensionsSnapshot;
     getSharedEntityLocalAndRemoteRevisions(changedAdaptableObjectId: TypeUuid, remoteSharedEntities: AdaptableSharedEntity[]): [number, number];
     getStaleActiveSharedEntities(): SharedEntityActiveStatus;
     showUpdateNotifications(): void;

package/src/Utilities/Services/TeamSharingService.js

@@ -1,5 +1,8 @@
 import { createUuid } from '../../AdaptableState/Uuid';
 import ObjectFactory from '../ObjectFactory';
+import { LayoutExtensionsSet } from '../../Redux/ActionsReducers/LayoutRedux';
+import { isLayoutExtensionModule } from '../Helpers/Layouts/LayoutExtensionHelper';
+import { AdaptableUpgradeHelper } from '../../migration/AdaptableUpgradeHelper';
 export class TeamSharingService {
     adaptableApi;
     dismissedNotifications = [];
@@ -71,6 +74,7 @@ export class TeamSharingService {
         });
         updatedEntityDependencyIds.push(...newSharedEntityDependencies.map((sharedEntity) => sharedEntity.Uuid));
         activeSharedEntity.EntityDependencyIds = updatedEntityDependencyIds;
+        this.setLayoutExtensionsSnapshot(activeSharedEntity);
         const updatedSharedEntities = sharedEntities.map((sharedEntity) => sharedEntity.Uuid === activeSharedEntity.Uuid ? activeSharedEntity : sharedEntity);
         updatedSharedEntities.push(...newSharedEntityDependencies);
         const updatedActiveEntities = [activeSharedEntity, ...newSharedEntityDependencies];
@@ -99,6 +103,44 @@ export class TeamSharingService {
         }));
         return [importSteps, configOverwriteNeedsConfirmation];
     }
+    buildLayoutExtensionImportActions(importSteps) {
+        const autoCheckTagsForLayouts = this.adaptableApi.optionsApi.getLayoutOptions().layoutTagOptions?.autoCheckTagsForLayouts ===
+            true;
+        return importSteps
+            .filter((step) => step.sharedEntity.Module === 'Layout')
+            .map((step) => {
+            const layoutName = step.sharedEntity.Entity.Name;
+            const extensionInfo = step.sharedEntity.LayoutExtensions ??
+                (autoCheckTagsForLayouts
+                    ? this.getLayoutExtensionInfoFromTags(layoutName, importSteps)
+                    : undefined);
+            return extensionInfo ? LayoutExtensionsSet(layoutName, extensionInfo) : undefined;
+        })
+            .filter(Boolean);
+    }
+    getLayoutExtensionInfoFromTags(layoutName, importSteps) {
+        const extensionInfo = {};
+        importSteps.forEach(({ sharedEntity }) => {
+            const { Module } = sharedEntity;
+            const Entity = sharedEntity.Entity;
+            if (isLayoutExtensionModule(Module) && Entity?.Name && Entity.Tags?.includes(layoutName)) {
+                (extensionInfo[Module] ??= []).push(Entity.Name);
+            }
+        });
+        return Object.keys(extensionInfo).length ? extensionInfo : undefined;
+    }
+    setLayoutExtensionsSnapshot(sharedEntity) {
+        if (sharedEntity.Module !== 'Layout') {
+            return;
+        }
+        const extensionInfo = this.adaptableApi.layoutApi.getLayoutExtensions(sharedEntity.Entity.Name);
+        if (Object.keys(extensionInfo).length) {
+            sharedEntity.LayoutExtensions = extensionInfo;
+        }
+        else {
+            delete sharedEntity.LayoutExtensions;
+        }
+    }
     getSharedEntityLocalAndRemoteRevisions(changedAdaptableObjectId, remoteSharedEntities) {
         const localRevision = this.adaptableApi.internalApi.getState().TeamSharing.ActiveSharedEntityMap[changedAdaptableObjectId]?.Revision ?? -1;
         const remoteRevision = remoteSharedEntities.find((sharedEntity) => sharedEntity.Entity.Uuid === changedAdaptableObjectId)?.Revision ?? -1;
@@ -216,7 +258,9 @@ export class TeamSharingService {
             ChangedAt: sharingTimestamp,
             Revision: 1,
             Type: configuration.type,
+            SharedAtMajorVersion: AdaptableUpgradeHelper.getCurrentMajorVersion(),
         };
+        this.setLayoutExtensionsSnapshot(mainSharedEntity);
         const teamSharingDependencies = this.getTeamSharingReferences(adaptableObject, module);
         teamSharingDependencies.forEach((teamSharingDependency) => {
             const sharedEntityDependency = this.createSharedEntity(teamSharingDependency.Reference, teamSharingDependency.Module, configuration, sharingUserName, sharingTimestamp, createdSharedEntities);

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

@@ -7,7 +7,6 @@ export declare class ValidationService implements IValidationService {
     constructor(adaptableApi: AdaptableApi);
     getValidationRulesForDataChange(cellDataChangedInfo: CellDataChangedInfo): AlertDefinition[];
     performValidation(cellDataChangedInfo: CellDataChangedInfo): boolean;
-    private IsAlertDefinitionTriggered;
     performServerValidation(cellDataChangedInfo: CellDataChangedInfo, config: {
         onServerValidationCompleted: () => void;
     }): () => boolean;

package/src/Utilities/Services/ValidationService.js

@@ -19,15 +19,23 @@ export class ValidationService {
         let failedValidations = [];
         if (ArrayExtensions.IsNotEmpty(editingRules)) {
             editingRules.forEach((alertDefinition) => {
-                if (alertDefinition.Rule.BooleanExpression) {
+                const rule = this.adaptableApi.alertApi.internalApi.resolveAlertRule(alertDefinition);
+                if (rule.kind === 'scalar' && rule.text) {
                     let isSatisfiedExpression = false;
                     try {
                         isSatisfiedExpression =
                             cellDataChangedInfo.rowNode != null &&
                                 this.adaptableApi.internalApi
                                     .getQueryLanguageService()
-                                    .evaluateBooleanExpression(alertDefinition.Rule.BooleanExpression, AlertModuleId, cellDataChangedInfo.rowNode, {
+                                    .evaluateBooleanExpression(rule.text, AlertModuleId, cellDataChangedInfo.rowNode, {
                                     columnScope: cellDataChangedInfo.column?.columnId,
+                                    cellValueOverride: cellDataChangedInfo.column
+                                        ? {
+                                            columnId: cellDataChangedInfo.column.columnId,
+                                            value: cellDataChangedInfo.newValue,
+                                        }
+                                        : undefined,
+                                    dataChangedEvent: cellDataChangedInfo,
                                 });
                     }
                     catch (error) {
@@ -38,11 +46,6 @@ export class ValidationService {
                         failedValidations.push(alertDefinition);
                     }
                 }
-                else {
-                    if (this.IsAlertDefinitionTriggered(alertDefinition, cellDataChangedInfo)) {
-                        failedValidations.push(alertDefinition);
-                    }
-                }
             });
         }
         return failedValidations;
@@ -62,22 +65,6 @@ export class ValidationService {
         }
         return true;
     }
-    IsAlertDefinitionTriggered(alertDefinition, dataChangedEvent) {
-        const displayValue = this.adaptableApi.gridApi.getDisplayValueFromRowNode(dataChangedEvent.rowNode, dataChangedEvent.column.columnId);
-        const predicateDefHandlerContext = {
-            value: dataChangedEvent.newValue,
-            oldValue: dataChangedEvent.oldValue,
-            rawValue: dataChangedEvent.newValue,
-            displayValue,
-            node: dataChangedEvent.rowNode,
-            column: dataChangedEvent.column,
-            ...this.adaptableApi.internalApi.buildBaseContext(),
-        };
-        if (!('Rule' in alertDefinition)) {
-            return false;
-        }
-        return this.adaptableApi.predicateApi.handlePredicates(alertDefinition.Rule.Predicates, predicateDefHandlerContext, false);
-    }
     performServerValidation(cellDataChangedInfo, config) {
         const serverValidationContext = {
             cellDataChangedInfo: cellDataChangedInfo,
@@ -121,12 +108,12 @@ export class ValidationService {
         }
         return (this.adaptableApi.columnScopeApi.getScopeDescription(alertDefinition.Scope) +
             ' ' +
-            alertDefinition.Rule.Predicates?.map((predicate) => this.adaptableApi.predicateApi.predicateToString(predicate)).join(' AND '));
+            (alertDefinition.Rule ?? ''));
     }
     createValidationMessage(alertDefinition) {
         let returnMessage = this.createValidationDescription(alertDefinition);
-        if ('Rule' in alertDefinition && alertDefinition.Rule.BooleanExpression) {
-            returnMessage += ' when ' + alertDefinition.Rule.BooleanExpression;
+        if ('Rule' in alertDefinition && alertDefinition.Rule) {
+            returnMessage += ' when ' + alertDefinition.Rule;
         }
         return returnMessage;
     }

package/src/Utilities/isPivotLayout.d.ts

@@ -1,2 +1,2 @@
-import { isPivotLayout } from '../Api/Implementation/LayoutHelpers';
+import { isPivotLayout } from './Helpers/Layouts/LayoutHelper';
 export { isPivotLayout };

package/src/Utilities/isPivotLayout.js

@@ -1,2 +1,2 @@
-import { isPivotLayout } from '../Api/Implementation/LayoutHelpers';
+import { isPivotLayout } from './Helpers/Layouts/LayoutHelper';
 export { isPivotLayout };

package/src/Utilities/logDeprecation.d.ts

@@ -1,6 +1,4 @@
 import { AdaptableLogger } from '../agGrid/AdaptableLogger';
 type StringKey<T> = Extract<keyof T, string>;
 export declare const logDeprecation: <T>(logger: AdaptableLogger, typeName: string, oldProp: StringKey<T>, newProp?: StringKey<T>, message?: string) => void;
-export declare const logDeprecationExternal: <OLD_TYPE, NEW_TYPE>(logger: AdaptableLogger, oldTypeName: string, oldProp: StringKey<OLD_TYPE>, newTypeName: string, newProp: StringKey<NEW_TYPE>, message?: string) => void;
-export declare const logDeprecationInternal: <T>(logger: AdaptableLogger, typeName: string, oldProp: StringKey<T>) => void;
 export {};

package/src/Utilities/logDeprecation.js

@@ -10,10 +10,3 @@ export const logDeprecation = (logger, typeName, oldProp, newProp, message) => {
     const newPropMsg = newProp ? `Please use '${typeName}.${newProp}()' instead. ` : '';
     doOnce(() => logger.consoleWarn(`${typeName}.${oldProp}() is deprecated. ${newPropMsg}${message ?? ''}`), `Deprecated_${oldProp}`);
 };
-export const logDeprecationExternal = (logger, oldTypeName, oldProp, newTypeName, newProp, message) => {
-    const newPropMsg = newProp ? `Please use '${newTypeName}.${newProp}()' instead. ` : '';
-    doOnce(() => logger.consoleWarn(`${oldTypeName}.${oldProp}() is deprecated. ${newPropMsg}${message ?? ''}`), `Deprecated_${oldProp}`);
-};
-export const logDeprecationInternal = (logger, typeName, oldProp) => {
-    doOnce(() => logger.consoleWarn(`${typeName}.${oldProp}() is deprecated and will be removed in the next major release. Contact support if you need this functionality.`), `Deprecated_${oldProp}`);
-};

package/src/Utilities/resolveContainerElement.js

@@ -1,8 +1,9 @@
+import { resolveValueOrFunction } from './Helpers/ValueOrFunctionHelper';
 export function resolveContainerElement(container, context, doc = globalThis.document) {
     if (container == null) {
         return null;
     }
-    const value = typeof container === 'function' ? container(context) : container;
+    const value = resolveValueOrFunction(container, context);
     if (value == null) {
         return null;
     }

package/src/View/AdaptableContext.d.ts

@@ -1,5 +1,7 @@
 import * as React from 'react';
+import { ReactNode } from 'react';
 import { IAdaptable } from '../AdaptableInterfaces/IAdaptable';
 declare const AdaptableContext: React.Context<IAdaptable>;
 export default AdaptableContext;
 export declare const useAdaptable: () => IAdaptable;
+export declare const renderWithAdaptableContext: (children: ReactNode, adaptable: IAdaptable) => React.JSX.Element;

package/src/View/AdaptableContext.js

@@ -1,7 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import * as React from 'react';
+import { Provider } from 'react-redux';
+import { TooltipProvider } from "../components/ui/tooltip";
 const AdaptableContext = React.createContext(null);
 export default AdaptableContext;
 export const useAdaptable = () => {
     const context = React.useContext(AdaptableContext);
     return context;
 };
+export const renderWithAdaptableContext = (children, adaptable) => {
+    return (_jsx(TooltipProvider, { delay: 300, children: _jsx(Provider, { store: adaptable.adaptableStore.TheStore, children: _jsx(AdaptableContext.Provider, { value: adaptable, children: children }) }) }));
+};

package/src/View/AdaptablePopover/index.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import * as React from 'react';
 import { StringExtensions } from '../../Utilities/Extensions/StringExtensions';
-import { UIHelper } from '../UIHelper';
+import { UIHelper } from '../../Utilities/Helpers/UIHelper';
 import { ButtonInfo } from '../Components/Buttons/ButtonInfo';
 import { Icon } from '../../components/icons';
 import { Popover, PopoverContent, PopoverTrigger } from '../../components/ui/popover';

package/src/View/AdaptableView.js

@@ -13,12 +13,14 @@ import { WindowPopups } from './Components/Popups/WindowPopups/WindowPopups';
 import { Dashboard } from './Dashboard/Dashboard';
 import { LicenseWatermark } from './License';
 import { QuickSearchDrawer } from './QuickSearch/FloatingQuickSearch/FloatingQuickSearch';
-import { renderWithAdaptableContext } from './renderWithAdaptableContext';
+import { FormulaTracePopup } from '../components/aql/FormulaTrace/FormulaTracePopup';
+import { CompactEditor } from '../components/aql/CompactEditor/CompactEditor';
+import { renderWithAdaptableContext } from './AdaptableContext';
 class AdaptableView extends React.Component {
     render() {
         const watermark = this.props.AdaptableApi?.internalApi?.getInternalState()?.License?.watermark;
         const adaptableOptions = this.props.AdaptableApi.optionsApi.getAdaptableOptions();
-        return (_jsxs("div", { children: [_jsx(GridCellPopup, {}), _jsx(QuickSearchDrawer, {}), this.props.AdaptableApi.internalApi
+        return (_jsxs("div", { children: [_jsx(GridCellPopup, {}), _jsx(FormulaTracePopup, {}), _jsx(CompactEditor, {}), _jsx(QuickSearchDrawer, {}), this.props.AdaptableApi.internalApi
                     .getModuleService()
                     .isAdapTableModulePresent('Dashboard') && _jsx(Dashboard, { api: this.props.AdaptableApi }), this.props.PopupState.PromptPopup.ShowPromptPopup && (_jsx(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 })), Boolean(this.props.PopupState.ConfirmationPopup.ShowConfirmationPopup) && (_jsx(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) && (_jsx(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 })), _jsx(ToastContainer, { containerId: `Toastify-${adaptableOptions.adaptableId}`, limit: adaptableOptions.notificationsOptions.maxNotifications, closeButton: false, icon: false, theme: "colored" }), watermark?.show && _jsx(LicenseWatermark, { children: watermark?.text }), _jsx(WindowPopups, {}), _jsx(FormPopups, {}), _jsx(ProgressIndicator, {})] }));
     }

package/src/View/AdaptableViewFactory.js

@@ -1,8 +1,8 @@
 import { SmartEditPopup } from './SmartEdit/SmartEditPopup';
 import { QuickSearchPopup } from './QuickSearch/QuickSearchPopup';
 import { ThemePopup } from './Theme/ThemePopup';
-import { ToolPanelPopup } from './Components/ToolPanel/ToolPanelPopup';
-import { GridInfoPopup } from './GridInfo/GridInfoPopup/GridInfoPopup';
+import { ToolPanelPopup } from './ToolPanel/ToolPanelPopup';
+import { GridInfoPopup } from './GridInfo/GridInfoPopup';
 import { DashboardPopup } from './Dashboard/DashboardPopup';
 import { StateManagementPopup } from './StateManagement/StateManagementPopup';
 import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
@@ -30,6 +30,7 @@ import { ChartingViewPanel } from './Charting/ChartingViewPanel';
 import { GridFilterPopup } from './GridFilter/GridFilterPopup';
 import { ColumnInfoPopup } from './ColumnInfo/ColumnInfoPopup';
 import { NotePopup } from './Note/NotePopup';
+import { NoteViewPanelControl } from './Note/NoteViewPanel';
 import { CommentsPopup } from './Comments/CommentsPopup';
 import { DataImportPopup } from './DataImport/DataImportPopup';
 export const AdaptableViewFactory = {
@@ -68,4 +69,5 @@ export const AdaptableViewPanelFactory = new Map([
     [ModuleConstants.DataChangeHistoryModuleId, DataChangeHistoryViewPanelControl],
     [ModuleConstants.StateManagementModuleId, StateManagementViewPanel],
     [ModuleConstants.ChartingModuleId, ChartingViewPanel],
+    [ModuleConstants.NoteModuleId, NoteViewPanelControl],
 ]);

package/src/View/AdaptableWizardView/Wizard.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useReducer, useState, useEffect } from 'react';
-import { prepareDataSource, prepareGridOptions } from './helper';
+import { prepareDataSource, prepareGridOptions } from './Utilities/helper';
 import ConfigurationDialog from './AdaptableConfigurationDialog';
 import FileDroppable from '../../components/FileDroppable';
-import { validDataSource } from './Utils';
+import { validDataSource } from './Utilities/Utils';
 import { Flex } from '../../components/Flex';
 export const initialState = {
     dropped: false,

package/src/View/Alert/ActiveAlertsPanel.js

@@ -3,15 +3,19 @@ import { useAdaptable } from '../AdaptableContext';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import { AdaptableObjectCompactList } from '../Components/AdaptableObjectList/AdaptableObjectCompactList';
 import { useSelector } from 'react-redux';
+import EmptyContent from '../../components/EmptyContent';
 export const ActiveAlertsPanel = () => {
     const adaptable = useAdaptable();
     const filterModule = adaptable.ModuleService.getModuleById(ModuleConstants.AlertModuleId);
     const alerts = useSelector((state) => state.Internal.AdaptableAlerts);
+    if (!alerts.length) {
+        return _jsx(EmptyContent, { children: "No Alerts have been triggered." });
+    }
     alerts.forEach((alert) => {
         const liveAlertDef = adaptable.api.alertApi.getAlertDefinitionById(alert.alertDefinition.Uuid);
         if (liveAlertDef) {
             alert.IsSuspended = liveAlertDef.IsSuspended;
         }
     });
-    return _jsx(AdaptableObjectCompactList, { abObjects: alerts, module: filterModule });
+    return (_jsx(AdaptableObjectCompactList, { abObjects: alerts, module: filterModule, showSuspendAllButton: false }));
 };

package/src/View/Alert/ActiveAlertsPanelItemLabel.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { allIcons } from '../../components/icons';
-import UIHelper from '../UIHelper';
+import UIHelper from '../../Utilities/Helpers/UIHelper';
 import { Box } from '../../components/Flex';
 export const ActiveAlertsPanelItemLabel = (props) => {
     const iconColor = UIHelper.getColorByMessageType(props.data.alertDefinition.MessageType);

package/src/View/Alert/AlertEmptyView.js

@@ -1,4 +1,4 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { ACCESS_LEVEL_READ_ONLY } from '../../Utilities/Constants/GeneralConstants';
 import { useAdaptable } from '../AdaptableContext';
 export const AlertEmptyView = (props) => {
@@ -7,5 +7,5 @@ export const AlertEmptyView = (props) => {
     const text = accessLevel == ACCESS_LEVEL_READ_ONLY
         ? 'You have no Alert Definitions.'
         : "Click 'New' to create a new Alert Definition - this will include the Rule which triggers the Alert, and the behaviour of the Alert.";
-    return _jsx(_Fragment, { children: text });
+    return _jsx("p", { children: text });
 };

package/src/View/Alert/AlertStatusSubPanel.js

@@ -5,7 +5,6 @@ import { useAdaptable } from '../AdaptableContext';
 import { getAlertButtonStyle } from './Utilities/getAlertButtonStyle';
 import { StatusBarPanel } from '../StatusBar/StatusBarPanel';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
-import { ActiveAlertsPanel } from './ActiveAlertsPanel';
 const initialStyle = { color: '', background: '' };
 export const AlertStatusPanel = () => {
     const adaptableApi = useAdaptable().api;
@@ -38,6 +37,5 @@ export const AlertStatusPanel = () => {
             setStyle(initialStyle);
         }, statusbarHighlightDuration);
     }, [alerts]);
-    let alertsPanel = _jsx(ActiveAlertsPanel, {});
-    return (_jsx(StatusBarPanel, { tooltip: module.moduleInfo.ModuleName, "data-name": module.moduleInfo.ModuleName, style: { backgroundColor: style.background, color: style.color }, onAction: handleAction, icon: module.moduleInfo.Glyph, popover: alerts.length ? alertsPanel : null, content: text }));
+    return (_jsx(StatusBarPanel, { tooltip: module.moduleInfo.ModuleName, "data-name": module.moduleInfo.ModuleName, style: { backgroundColor: style.background, color: style.color }, onAction: handleAction, icon: module.moduleInfo.Glyph, content: text }));
 };