@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/src/Utilities/Services/CommentsService.js

@@ -0,0 +1,128 @@
+import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
+import ArrayExtensions from '../Extensions/ArrayExtensions';
+export class CommentsService {
+    api;
+    adaptable;
+    isListeningToEvents;
+    constructor(api) {
+        this.api = api;
+        this.isListeningToEvents = false;
+        this.adaptable = api.internalApi.getAdaptableInstance();
+        this.adaptable.api.eventApi.on('AdaptableReady', () => this.checkListenToEvents());
+    }
+    destroy() { }
+    getAdaptableState() {
+        return this.api.internalApi.getAdaptableState();
+    }
+    dispatchAction(action) {
+        this.api.internalApi.dispatchReduxAction(action);
+    }
+    static isSameAddress(a, b) {
+        if (!a || !b) {
+            return false;
+        }
+        if (a?.ColumnId === b?.ColumnId && a?.PrimaryKeyValue === b?.PrimaryKeyValue) {
+            return true;
+        }
+        if ((typeof a.PrimaryKeyValue === 'number' && typeof b.PrimaryKeyValue === 'string') ||
+            (typeof b.PrimaryKeyValue === 'string' && typeof a.PrimaryKeyValue === 'number')) {
+            return (a.PrimaryKeyValue.toString() === b.PrimaryKeyValue.toString() && a.ColumnId === b.ColumnId);
+        }
+        return false;
+    }
+    checkListenToEvents() {
+        if (!this.isListeningToEvents && this.shouldListenToEvents()) {
+            this.setUpEventListeners();
+            this.isListeningToEvents = true;
+        }
+    }
+    shouldListenToEvents() {
+        return this.api.internalApi.getModuleService().isAdapTableModulePresent('Comment');
+    }
+    setUpEventListeners() {
+        this.adaptable._on('MouseEnter', (event) => this.handleMouseEnter(event));
+        this.api.eventApi.on('CellSelectionChanged', (params) => {
+            const cells = params.selectedCellInfo.gridCells;
+            if (ArrayExtensions.hasOneItem(cells)) {
+                const selectedCell = cells[0];
+                if (selectedCell.column?.columnId && selectedCell.primaryKeyValue) {
+                    const selectedCellAddress = {
+                        PrimaryKeyValue: selectedCell.primaryKeyValue,
+                        ColumnId: selectedCell.column.columnId,
+                    };
+                    this.handleCellSelected(selectedCellAddress);
+                }
+            }
+        });
+    }
+    getCellPositionFromEvent(event) {
+        const target = event.target;
+        if (!target?.classList?.contains?.('ag-cell')) {
+            return null;
+        }
+        const rowElement = target.closest('[row-id]');
+        const PrimaryKeyValue = rowElement?.getAttribute('row-id');
+        const ColumnId = target.getAttribute('col-id');
+        if (PrimaryKeyValue == null || ColumnId == null) {
+            return null;
+        }
+        return {
+            PrimaryKeyValue,
+            ColumnId,
+        };
+    }
+    handleMouseEnter(event) {
+        const editMode = this.getEditMode();
+        if (editMode) {
+            return;
+        }
+        const cellPosition = this.getCellPositionFromEvent(event);
+        const openCellAddress = this.getOpenCellAddress();
+        if (!cellPosition && openCellAddress) {
+            this.hidePopup();
+            return;
+        }
+        if (CommentsService.isSameAddress(openCellAddress, cellPosition)) {
+            return;
+        }
+        const cellComments = this.api.commentApi.getCommentThreadForCell(cellPosition);
+        const showCommentMode = this.api.optionsApi.getCommentOptions()?.showCommentAction ?? 'hover';
+        const shouldOpenForComment = !!cellComments && showCommentMode === 'hover';
+        if (!shouldOpenForComment) {
+            return;
+        }
+        this.showPopup(cellPosition, false);
+    }
+    handleCellSelected(cellAddress) {
+        const openCellAddress = this.getOpenCellAddress();
+        if (CommentsService.isSameAddress(openCellAddress, cellAddress)) {
+            return;
+        }
+        const cellComments = this.api.commentApi.getCommentThreadForCell(cellAddress);
+        if (openCellAddress && !cellComments) {
+            if (this.getEditMode()) {
+                this.hidePopup();
+            }
+            return;
+        }
+        if (openCellAddress && cellComments) {
+            this.showPopup(cellAddress, true);
+            return;
+        }
+    }
+    getOpenCellAddress() {
+        return InternalRedux.CommentPopupPositionSelector(this.getAdaptableState().Internal);
+    }
+    getEditMode() {
+        return InternalRedux.CommentPopupEditModeSelector(this.getAdaptableState().Internal);
+    }
+    hidePopup() {
+        this.dispatchAction(InternalRedux.CellPopupHide());
+    }
+    showPopup(cellAddress, editMode) {
+        this.dispatchAction(InternalRedux.CellPopupShow(cellAddress, editMode));
+    }
+    editFocusedEntity(entity) {
+        this.dispatchAction(InternalRedux.CellPopupEditFocusedEntity(entity));
+    }
+}

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

@@ -2,25 +2,22 @@ import { IDataService } from './Interface/IDataService';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { CellDataChangedInfo } from '../../AdaptableState/Common/CellDataChangedInfo';
 import { EmitterCallback } from '../../Utilities/Emitter';
-import { Observable } from 'rxjs';
 import { RowDataChangedInfo } from '../../types';
 export declare class DataService implements IDataService {
     private adaptable;
     private emitter;
-    private cellDataChangeLogSubject$;
-    cellDataChangeLog$: Observable<CellDataChangedInfo>;
-    private rowDataChangeLogSubject$;
-    rowDataChangeLog$: Observable<RowDataChangedInfo>;
     private undoChangeLog;
     private undoChangeTimers;
+    private dataChangeBatchDepth;
     constructor(adaptable: IAdaptable);
     destroy(): void;
     on: (eventName: string, callback: EmitterCallback) => (() => void);
     emit: (eventName: string, data?: any) => Promise<any>;
+    startDataChangeBatch(): void;
+    endDataChangeBatch(): void;
     CreateCellDataChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
     CreateRowDataChangedEvent(rowDataChangedInfo: RowDataChangedInfo): void;
     logUndoChange(change: CellDataChangedInfo): void;
     extractUndoChange(change: CellDataChangedInfo): CellDataChangedInfo | undefined;
     private getUndoChangeKey;
-    private extractDataChangeLogEntry;
 }

package/src/Utilities/Services/DataService.js

@@ -1,36 +1,20 @@
 import Emitter from '../../Utilities/Emitter';
-import { Subject } from 'rxjs';
-import Helper from '../Helpers/Helper';
-const MAX_TIMEFRAME_SIZE = 86400000;
 export class DataService {
     adaptable;
     emitter;
-    cellDataChangeLogSubject$;
-    cellDataChangeLog$;
-    rowDataChangeLogSubject$;
-    rowDataChangeLog$;
     undoChangeLog;
     undoChangeTimers;
+    dataChangeBatchDepth = 0;
     constructor(adaptable) {
         this.adaptable = adaptable;
         this.adaptable = adaptable;
         this.emitter = new Emitter();
-        this.cellDataChangeLogSubject$ = new Subject();
-        this.cellDataChangeLog$ = this.cellDataChangeLogSubject$.asObservable();
-        this.rowDataChangeLogSubject$ = new Subject();
-        this.rowDataChangeLog$ = this.rowDataChangeLogSubject$.asObservable();
         this.undoChangeLog = new Map();
         this.undoChangeTimers = new Map();
     }
     destroy() {
         this.emitter.destroy();
         this.emitter = null;
-        this.cellDataChangeLogSubject$.complete();
-        this.cellDataChangeLogSubject$ = null;
-        this.cellDataChangeLog$ = null;
-        this.rowDataChangeLogSubject$.complete();
-        this.rowDataChangeLogSubject$ = null;
-        this.rowDataChangeLog$ = null;
         this.undoChangeLog.clear();
         this.undoChangeLog = null;
         this.undoChangeTimers.clear();
@@ -38,6 +22,21 @@ export class DataService {
     }
     on = (eventName, callback) => this.emitter.on(eventName, callback);
     emit = (eventName, data) => this.emitter.emit(eventName, data);
+    startDataChangeBatch() {
+        this.dataChangeBatchDepth++;
+        if (this.dataChangeBatchDepth === 1) {
+            this.emitter.emitSync('DataChangeBatchStarted', undefined);
+        }
+    }
+    endDataChangeBatch() {
+        if (this.dataChangeBatchDepth === 0) {
+            return;
+        }
+        this.dataChangeBatchDepth--;
+        if (this.dataChangeBatchDepth === 0) {
+            this.emitter.emitSync('DataChangeBatchEnded', undefined);
+        }
+    }
     CreateCellDataChangedEvent(cellDataChangedInfo) {
         if (cellDataChangedInfo.newValue != cellDataChangedInfo.oldValue) {
             const validationRules = this.adaptable.api.internalApi
@@ -46,16 +45,15 @@ export class DataService {
             if (validationRules.length) {
                 cellDataChangedInfo.preventEdit = true;
             }
+            this.emitter.emitSync('BeforeCellDataChanged', cellDataChangedInfo);
             this.emitter.emitSync('CellDataChanged', cellDataChangedInfo);
             this.adaptable.api.eventApi.internalApi.fireCellChangedEvent(cellDataChangedInfo);
-            const dataChangeLogEntry = this.extractDataChangeLogEntry(cellDataChangedInfo);
-            this.cellDataChangeLogSubject$.next(dataChangeLogEntry);
         }
     }
     CreateRowDataChangedEvent(rowDataChangedInfo) {
+        this.emitter.emitSync('BeforeRowDataChanged', rowDataChangedInfo);
         this.emitter.emitSync('RowDataChanged', rowDataChangedInfo);
         this.adaptable.api.eventApi.internalApi.fireRowChangedEvent(rowDataChangedInfo);
-        this.rowDataChangeLogSubject$.next(rowDataChangedInfo);
     }
     logUndoChange(change) {
         const { primaryKeyValue, column, oldValue, newValue } = change;
@@ -87,15 +85,4 @@ export class DataService {
             newValue,
         });
     }
-    extractDataChangeLogEntry(cellDataChangedInfo) {
-        const rowData = cellDataChangedInfo.rowData
-            ? Helper.cloneObject(cellDataChangedInfo.rowData)
-            : null;
-        const rowNode = rowData ? { data: rowData } : null;
-        return {
-            ...cellDataChangedInfo,
-            rowNode,
-            rowData,
-        };
-    }
 }

package/src/Utilities/Services/Interface/IAlertLiveBindingService.d.ts

@@ -0,0 +1,41 @@
+import type { IRowNode } from 'ag-grid-enterprise';
+import type { RuleBasedAlertDefinition } from '../../../AdaptableState/AlertState';
+import type { TypeUuid } from '../../../AdaptableState/Uuid';
+import { IAdaptableService } from './IAdaptableService';
+/** Current reading of a live Alert rule: `'Firing'` while the rule holds. */
+export type AlertRuleState = 'Normal' | 'Firing';
+/**
+ * Runs the *live* Alert rules — rules that read change history
+ * (`CHANGE_COUNT{[price], WITHIN(5m)} >= 3`) or the clock (`IS_PAST([expiry])`)
+ * and can therefore change with no data change behind them.
+ *
+ * Each bound definition owns one computed-value-store node. The store
+ * re-executes the node on relevant data changes and on window expiry; on
+ * every landing the service re-reads the rows that may have flipped and
+ * fires the Alert on the false → true transition only (`FireOn:
+ * 'BecomeTrue'`). The first evaluation *seeds* the state silently, so rules
+ * already true at bind time do not fire.
+ *
+ * Per-row rules keep one state per row id; grid-level rules
+ * (`ROWS_ADDED{WITHIN(5s)} >= 3`, `CHANGE_COUNT{[price], WITHIN(1m), ALL_ROWS()}`)
+ * keep a single state.
+ */
+export interface IAlertLiveBindingService extends IAdaptableService {
+    /** Binds (or re-binds, on edit) one definition; the first flush seeds. */
+    bind(alertDefinition: RuleBasedAlertDefinition): void;
+    unbind(alertDefinitionUuid: TypeUuid): void;
+    isBound(alertDefinitionUuid: TypeUuid): boolean;
+    /**
+     * Binds every active live definition not yet bound and unbinds definitions
+     * no longer active. Called on module start and on the suspend-all /
+     * unsuspend-all actions.
+     */
+    syncFromState(): void;
+    /**
+     * `'Firing'` while the rule currently holds for the row (per-row rules) or
+     * for the grid (grid-level rules); `undefined` when the definition is not
+     * bound or the row was never evaluated.
+     */
+    getState(alertDefinitionUuid: TypeUuid, rowNode?: IRowNode): AlertRuleState | undefined;
+    destroy(): void;
+}

package/src/Utilities/Services/Interface/IAlertLiveBindingService.js

@@ -0,0 +1 @@
+export {};

package/src/Utilities/Services/Interface/ICalculatedColumnExpressionService.d.ts

@@ -1,15 +1,52 @@
 import { IAdaptableService } from './IAdaptableService';
 import { IRowNode } from 'ag-grid-enterprise';
-import { AdaptableCalculatedColumnQuery, CalculatedColumn, CalculatedColumnSettings } from '../../../AdaptableState/CalculatedColumnState';
+import { CalculatedColumn, CalculatedColumnSettings } from '../../../AdaptableState/CalculatedColumnState';
+import type { ResolvedExpression } from '../../../AdaptableState/Common/AdaptableQuery';
 import { CellDataChangedInfo } from '../../../AdaptableState/Common/CellDataChangedInfo';
-import { RowDataChangedInfo } from '../../../AdaptableState/Common/RowDataChangedInfo';
+import type { LiveRefreshTarget } from './ILiveRefreshService';
+export interface InferredCalculatedColumnTypes {
+    DataType: CalculatedColumnSettings['DataType'];
+    CellDataType?: string;
+}
+/**
+ * An Observable Calculated Column whose history read can move when `columnId`
+ * changes. `rowIndependent` is `ALL_ROWS()` / grid-scoped (same value on
+ * every row); otherwise only the edited row needs a repaint.
+ */
+export interface ObservableCalculatedColumnRefresh {
+    columnId: string;
+    rowIndependent: boolean;
+}
 export interface ICalculatedColumnExpressionService extends IAdaptableService {
-    isCalculatedColumnQueryValid(calculatedColumnQuery: AdaptableCalculatedColumnQuery): boolean;
+    /**
+     * The column's Query paired with its inferred kind (`scalar` per-row or
+     * `aggregated` over the row set). The persisted `Type` only acts as the
+     * fallback for text with no kind of its own (empty / unparseable).
+     */
+    resolveCalculatedColumnQuery(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>): ResolvedExpression;
+    isAggregatedCalculatedColumn(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>): boolean;
+    isCalculatedColumnQueryValid(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>, calculatedColumnId?: string): boolean;
     evaluateCalculatedColumnQuery(calculatedColumn: CalculatedColumn, rowNode: IRowNode): any;
-    getCalculatedColumnDataType(calculatedColumnQuery: AdaptableCalculatedColumnQuery): CalculatedColumnSettings['DataType'];
-    createAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
-    destroyAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
-    listentoCellDataChange(cellDataChangedInfo: CellDataChangedInfo): void;
-    listentoRowDataChange(rowDataChangedInfo: RowDataChangedInfo): void;
+    getCalculatedColumnDataType(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>): CalculatedColumnSettings['DataType'];
+    /**
+     * The column types inferred from the expression: the AdapTable `DataType`
+     * plus, when the expression yields a `duration`, the `duration` AG Grid
+     * `CellDataType` (a number underneath, rendered as `4m 05s`).
+     */
+    inferCalculatedColumnTypes(calculatedColumn: Pick<CalculatedColumn, 'Type' | 'Expression'>): InferredCalculatedColumnTypes;
+    /**
+     * Cells to repaint on the live-refresh cadence, when the expression can
+     * change with no data change (sliding window or clock read); `undefined`
+     * for every other column.
+     */
+    getLiveRefreshTarget(calculatedColumn: CalculatedColumn): LiveRefreshTarget | undefined;
+    /**
+     * Observable Calculated Columns that read `columnId` (or `ANY_COL()`).
+     * Used after a cell change to force-refresh getters now that history
+     * contains the change — separate from derived `CellDataChanged` events.
+     */
+    getObservableCalculatedColumnsAffectedByColumn(columnId: string): ObservableCalculatedColumnRefresh[];
+    bindAggregatedCalculatedColumn(calculatedColumn: CalculatedColumn): void;
+    unbindAggregatedCalculatedColumn(calculatedColumn: CalculatedColumn): void;
     buildSyntheticCellDataChangedInfosForCalcColumns(cellDataChangedInfo: CellDataChangedInfo): CellDataChangedInfo[];
 }

package/src/Utilities/Services/Interface/IDataService.d.ts

@@ -1,14 +1,36 @@
 import { CellDataChangedInfo } from '../../../AdaptableState/Common/CellDataChangedInfo';
-import { Observable } from 'rxjs';
 import { IAdaptableService } from './IAdaptableService';
 import { RowDataChangedInfo } from '../../../types';
 export interface IDataService extends IAdaptableService {
     CreateCellDataChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
     CreateRowDataChangedEvent(rowDataChangedInfo: RowDataChangedInfo): void;
+    /**
+     * Marks the start of a group of data changes that should be treated as a single action (e.g. the
+     * updates applied by Bulk Update or Smart Edit). Re-entrant: a matching `endDataChangeBatch` must
+     * be called for each `startDataChangeBatch`. A `DataChangeBatchStarted` event is emitted when the
+     * outermost batch opens. This is a generic, module-agnostic signal - `DataService` does not know
+     * or care who (if anyone) reacts to it.
+     */
+    startDataChangeBatch(): void;
+    /**
+     * Marks the end of a group of data changes started with `startDataChangeBatch`. A
+     * `DataChangeBatchEnded` event is emitted when the outermost batch closes.
+     */
+    endDataChangeBatch(): void;
+    /**
+     * Fired synchronously immediately before `CellDataChanged`, with the same
+     * payload. Reserved for the expression history feed (QueryLanguageService):
+     * observable reads inside `CellDataChanged` listeners (Flashing Cell, Alert
+     * rules) must already see the change. Feature modules subscribe to
+     * `CellDataChanged`.
+     */
+    on(eventName: 'BeforeCellDataChanged', callback: (cellDataChangedInfo: CellDataChangedInfo) => void): () => void;
     on(eventName: 'CellDataChanged', callback: (cellDataChangedInfo: CellDataChangedInfo) => void): () => void;
+    /** Row counterpart of `BeforeCellDataChanged`. */
+    on(eventName: 'BeforeRowDataChanged', callback: (rowDataChangedInfo: RowDataChangedInfo) => void): () => void;
     on(eventName: 'RowDataChanged', callback: (rowDataChangedInfo: RowDataChangedInfo) => void): () => void;
-    readonly cellDataChangeLog$: Observable<CellDataChangedInfo>;
-    readonly rowDataChangeLog$: Observable<RowDataChangedInfo>;
+    on(eventName: 'DataChangeBatchStarted', callback: () => void): () => void;
+    on(eventName: 'DataChangeBatchEnded', callback: () => void): () => void;
     logUndoChange(undoChange: CellDataChangedInfo): void;
     extractUndoChange(undoChange: CellDataChangedInfo): CellDataChangedInfo | undefined;
 }

package/src/Utilities/Services/Interface/ILiveRefreshService.d.ts

@@ -0,0 +1,39 @@
+import { IAdaptableService } from './IAdaptableService';
+/**
+ * Which cells a live rule owner needs repainted on the refresh cadence.
+ */
+export type LiveRefreshTarget = {
+    kind: 'columns';
+    columnIds: readonly string[];
+} | {
+    kind: 'allColumns';
+};
+/**
+ * Repaints, on a fixed cadence, the cells whose expressions can change
+ * without any data change: sliding windows expiring (`WITHIN(...)`) and
+ * clock reads (`NOW()`, `IS_PAST()`, `ROW_AGE{}`).
+ *
+ * Owners (a Calculated Column, a Format Column, a Styled Column badge) register
+ * a target; the interval runs only while at least one owner is registered and
+ * stops at zero, so a grid without live rules pays nothing.
+ * `expressionOptions.liveRefreshIntervalMs` sets the cadence; `0` disables
+ * the service — live cells then only repaint on data changes.
+ *
+ * A tick never re-sorts, re-filters or re-groups: it re-runs value getters and
+ * cell styles of the rendered rows only (`refreshCells`).
+ */
+export interface ILiveRefreshService extends IAdaptableService {
+    /** Idempotent per owner: re-registering replaces the owner's target. */
+    register(ownerKey: string, target: LiveRefreshTarget): void;
+    unregister(ownerKey: string): void;
+    /**
+     * Recomputes the registrations of every rule in Adaptable State that
+     * depends on time or on a sliding window (Calculated Columns, Format
+     * Columns, Styled Column badges). Called on state load and on the
+     * add / edit / delete / suspend actions of those modules.
+     */
+    syncFromState(): void;
+    /** Whether the refresh interval is currently running (diagnostics / tests). */
+    isRunning(): boolean;
+    destroy(): void;
+}

package/src/Utilities/Services/Interface/ILiveRefreshService.js

@@ -0,0 +1 @@
+export {};