@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.1

package/src/AdaptableState/AlertState.d.ts

@@ -1,13 +1,10 @@
 import { BaseState } from './BaseState';
 import { ColumnScope } from './Common/ColumnScope';
-import { AdaptableColumnPredicate } from './Common/AdaptablePredicate';
-import { TypeHint } from './Common/Types';
 import { AdaptableMessageType } from './Common/AdaptableMessageType';
 import { AdaptableForm } from './Common/AdaptableForm';
 import { AdaptableButton } from './Common/AdaptableButton';
 import { AdaptableStyle } from './Common/AdaptableStyle';
-import { XOR } from '../Utilities/Extensions/TypeExtensions';
-import { AdaptableAggregatedBooleanQuery, AdaptableBooleanQuery, AdaptableObservableQuery } from './Common/AdaptableQuery';
+import type { ExpressionKind } from './Common/AdaptableQuery';
 import { ButtonStyle } from './Common/ButtonStyle';
 import { Schedule } from './Common/Schedule';
 import { AlertFormContext, BaseContext, NotificationsOptions, SuspendableObject } from '../types';
@@ -20,6 +17,26 @@ export interface AlertState extends BaseState {
      */
     AlertDefinitions?: AlertDefinition[];
 }
+/**
+ * Wizard / evaluation category for an Alert Definition.
+ *
+ * Persisted on {@link AlertDefinitionBase.Type}. When absent (legacy state),
+ * inferred from Rule / Schedule shape via migration and runtime fallback.
+ */
+export type AlertType = 'DataChange' | 'RelativeChange' | 'Validation' | 'RowChange' | 'Aggregation' | 'Observable' | 'Scheduled';
+/**
+ * Runtime constants matching {@link AlertType} (replaces the previous View-layer enum).
+ */
+export declare const AlertType: {
+    readonly DataChange: "DataChange";
+    readonly RelativeChange: "RelativeChange";
+    readonly Validation: "Validation";
+    readonly RowChange: "RowChange";
+    readonly Aggregation: "Aggregation";
+    readonly Observable: "Observable";
+    readonly Scheduled: "Scheduled";
+};
+export declare const ALERT_TYPES: readonly AlertType[];
 /**
  * Fields shared by all alert definitions
  */
@@ -28,6 +45,12 @@ export interface AlertDefinitionBase extends SuspendableObject {
      * Name of the Alert Definition
      */
     Name: string;
+    /**
+     * Alert category (Data Change, Relative Change, Validation, etc.).
+     * Optional for one release so legacy InitialState migrates via VersionUpgrade24;
+     * when omitted, inferred from Rule / Schedule.
+     */
+    Type?: AlertType;
     /**
      * Type of Alert: 'Info', 'Success', 'Warning', 'Error'; influences Alert colour, icon and logging
      */
@@ -50,9 +73,65 @@ export interface RuleBasedAlertDefinition extends AlertDefinitionBase {
      */
     Scope: ColumnScope;
     /**
-     * When Alert should be triggered
+     * AdapTableQL boolean expression deciding when the Alert is triggered.
+     *
+     * The kind is inferred from the text: a per-row rule such as
+     * `[price] > 100`, an aggregated rule such as `SUM{[notional]} > 1000000`,
+     * or a live (observable) rule such as `CHANGE_COUNT{[price], WITHIN(5m)} >= 3`.
+     */
+    Rule: string;
+    /**
+     * When a live rule (one reading change history — `CHANGE_COUNT{[price],
+     * WITHIN(5m)} >= 3` — or the clock) fires. Live rules are re-evaluated on
+     * data changes and on window expiry alike, and fire only on the transition
+     * from false to true (per row, or once for a grid-level rule). Ignored for
+     * every other rule.
      */
-    Rule: AlertRule;
+    TriggerPolicy?: AlertTriggerPolicy;
+    /**
+     * Properties which set what happens when the Alert is triggered (notification and grid behaviours)
+     */
+    AlertProperties?: RuleAlertProperties;
+    /**
+     * Form to display in Alert with buttons and inputs
+     */
+    AlertForm?: string | AlertButtonForm;
+}
+/**
+ * Firing policy of a live (observable / clock-reading) alert rule.
+ */
+export interface AlertTriggerPolicy {
+    /**
+     * `'BecomeTrue'` (the only policy, and the default): fire when the rule
+     * turns from false to true; stay silent while it remains true; a rule that
+     * is already true when the Alert is created does not fire until it turns
+     * false and true again.
+     */
+    FireOn?: 'BecomeTrue';
+}
+/**
+ * Alert that fires when a row is added to or removed from the grid.
+ *
+ * Replaces the legacy observable `ROW_ADDED{}` / `ROW_REMOVED{}` rules: one Alert per
+ * row event, with an optional per-row {@link RowChangeAlertDefinition.Rule}
+ * (`[make] = 'Toyota'`) evaluated on the added / removed row.
+ */
+export interface RowChangeAlertDefinition extends AlertDefinitionBase {
+    Type: 'RowChange';
+    /**
+     * Kept for uniformity with the other grid Alerts; Row Change Alerts apply
+     * to the whole row (`{ All: true }`).
+     */
+    Scope: ColumnScope;
+    /**
+     * Which row event fires the Alert.
+     */
+    RowChangeTrigger: 'Added' | 'Removed';
+    /**
+     * Optional boolean expression evaluated on the added / removed row; when
+     * absent every row event fires.
+     */
+    Rule?: string;
     /**
      * Properties which set what happens when the Alert is triggered (notification and grid behaviours)
      */
@@ -77,31 +156,33 @@ export interface ScheduledAlertDefinition extends AlertDefinitionBase {
 }
 /**
  * The Alert Definition object used in the Alert function.
- * Provide either a {@link Rule} (with {@link Scope}) or a {@link Schedule}, not both.
+ * Provide a {@link RuleBasedAlertDefinition.Rule} (with a Scope), a
+ * {@link RowChangeAlertDefinition.RowChangeTrigger}, or a
+ * {@link ScheduledAlertDefinition.Schedule}.
  */
-export type AlertDefinition = RuleBasedAlertDefinition | ScheduledAlertDefinition;
+export type AlertDefinition = RuleBasedAlertDefinition | RowChangeAlertDefinition | ScheduledAlertDefinition;
 /**
- * Form triggered by an Alert which contains only Buttons
+ * Alert definitions evaluated against the grid (everything but Scheduled):
+ * they carry a Scope, grid behaviours and — optionally for Row Change — a Rule.
  */
-export type AlertButtonForm = Omit<AdaptableForm<AlertFormContext>, 'title' | 'buttons' | 'description'> & {
-    Buttons?: AlertButton<AlertFormContext>[];
-};
+export type GridAlertDefinition = RuleBasedAlertDefinition | RowChangeAlertDefinition;
 /**
- * Predicate used when creating a Predicate-based Rule for an Alert
+ * Row Change Alert in its current shape (`RowChangeTrigger`). Pre-v24
+ * `Type: 'RowChange'` definitions with a `ROW_ADDED{}` rule and no trigger
+ * are not matched: `VersionUpgrade24` rewrites them on load.
  */
-export interface AlertDefinitionPredicate extends AdaptableColumnPredicate {
-    PredicateId: TypeHint<string, SystemAlertPredicateId>;
-}
+export declare const isRowChangeAlertDefinition: (alertDefinition: AlertDefinition | undefined | null) => alertDefinition is RowChangeAlertDefinition;
 /**
- * The Alert Rule defined by either an AdaptablePredicate or an AdaptableQuery
+ * Form triggered by an Alert which contains only Buttons
  */
-export type AlertRule = XOR<{
-    Predicates: AlertDefinitionPredicate[];
-}, AdaptableAlertQuery>;
+export type AlertButtonForm = Omit<AdaptableForm<AlertFormContext>, 'title' | 'buttons' | 'description'> & {
+    Buttons?: AlertButton<AlertFormContext>[];
+};
 /**
- *  Alert Query which may be either a Boolean, Observable or AggregatedBoolean Expression
+ * {@link ExpressionKind} an Alert of the given type is expected to hold;
+ * `undefined` for Scheduled alerts (no Rule).
  */
-export type AdaptableAlertQuery = XOR<AdaptableBooleanQuery, XOR<AdaptableObservableQuery, AdaptableAggregatedBooleanQuery>>;
+export declare const expressionKindForAlertType: (type: AlertType | undefined) => ExpressionKind | undefined;
 /**
  * Commands available in an Alert
  */
@@ -187,11 +268,3 @@ export interface ScheduledAlertProperties extends AlertPresentationProperties {
      */
     IncludeSuspendButton?: boolean;
 }
-/**
- * Array containing all System Alert Predicates
- */
-export type SystemAlertPredicateIds = SystemAlertPredicateId[];
-/**
- * List of System Predicates available for Alerts
- */
-export type SystemAlertPredicateId = 'Blanks' | 'NonBlanks' | 'Equals' | 'NotEquals' | 'GreaterThan' | 'LessThan' | 'Positive' | 'Negative' | 'Zero' | 'Between' | 'NotBetween' | 'Is' | 'IsNot' | 'Contains' | 'NotContains' | 'StartsWith' | 'EndsWith' | 'Regex' | 'Today' | 'Yesterday' | 'Tomorrow' | 'ThisWeek' | 'ThisMonth' | 'ThisQuarter' | 'ThisYear' | 'InPast' | 'InFuture' | 'Before' | 'After' | 'On' | 'NotOn' | 'NextWorkDay' | 'LastWorkDay' | 'WorkDay' | 'Holiday' | 'True' | 'False' | 'PercentChange' | 'In' | 'NotIn' | 'AnyChange';

package/src/AdaptableState/AlertState.js

@@ -1 +1,35 @@
-export {};
+export const AlertType = {
+    DataChange: 'DataChange',
+    RelativeChange: 'RelativeChange',
+    Validation: 'Validation',
+    RowChange: 'RowChange',
+    Aggregation: 'Aggregation',
+    Observable: 'Observable',
+    Scheduled: 'Scheduled',
+};
+export const ALERT_TYPES = [
+    AlertType.DataChange,
+    AlertType.RelativeChange,
+    AlertType.Validation,
+    AlertType.RowChange,
+    AlertType.Aggregation,
+    AlertType.Observable,
+    AlertType.Scheduled,
+];
+export const isRowChangeAlertDefinition = (alertDefinition) => alertDefinition != null &&
+    alertDefinition.Type === 'RowChange' &&
+    'RowChangeTrigger' in alertDefinition;
+export const expressionKindForAlertType = (type) => {
+    switch (type) {
+        case 'Aggregation':
+            return 'aggregated';
+        case 'DataChange':
+        case 'RelativeChange':
+        case 'Validation':
+        case 'Observable':
+        case 'RowChange':
+            return 'scalar';
+        default:
+            return undefined;
+    }
+};

package/src/AdaptableState/CalculatedColumnState.d.ts

@@ -1,8 +1,8 @@
 import { BaseState } from './BaseState';
 import { AdaptableObject } from './Common/AdaptableObject';
-import { AdaptableAggregatedScalarQuery, AdaptableScalarQuery } from './Common/AdaptableQuery';
+import { expressionContainsAggregation, expressionContainsObservableCall, type ExpressionKind } from './Common/AdaptableQuery';
 import { SpecialColumnSettings } from './Common/SpecialColumnSettings';
-import { XOR } from '../Utilities/Extensions/TypeExtensions';
+export { expressionContainsAggregation, expressionContainsObservableCall };
 /**
  * Adaptable State Section for Calculated Column Module
  **/
@@ -13,7 +13,7 @@ export interface CalculatedColumnState extends BaseState {
     CalculatedColumns?: CalculatedColumn[];
 }
 /**
- *  Defines a Column where the display value is derived from other values in row, and the definition is stored in State.
+ *  Defines a Column where value is derived from other values in row, and the definition is stored in State
  */
 export interface CalculatedColumn extends AdaptableObject {
     /**
@@ -24,14 +24,25 @@ export interface CalculatedColumn extends AdaptableObject {
      * Name to be used in Column Header; if blank `ColumnId` is used
      */
     FriendlyName?: string;
+    /**
+     * Calculated Column category: `Standard` / `Observable` (per-row) or
+     * `Aggregated` / `Cumulative` / `Quantile` / `Window` (over rows).
+     * See {@link CalculatedColumnType}.
+     */
+    Type?: CalculatedColumnType;
     /**
      * Additional optional properties for Column (e.g. filterable, resizable)
      */
     CalculatedColumnSettings: CalculatedColumnSettings;
     /**
-     * Scalar/AggregatedScalar Query used by AdapTableQL to evaluate Column's value
+     * AdapTableQL Expression used to evaluate the Column's value.
+     *
+     * The kind is inferred from the text: a per-row expression such as
+     * `[quantity] * [price]` yields a Standard column; an expression containing
+     * an aggregation such as `SUM{[notional], GROUP_BY([sector])}` or
+     * `[price] / AVG{[price]}` is evaluated over the row set.
      */
-    Query: AdaptableCalculatedColumnQuery;
+    Expression: string;
 }
 /**
  * Set properties that define Calculated Column's behaviour (all optional except DataType)
@@ -43,7 +54,63 @@ export interface CalculatedColumnSettings extends SpecialColumnSettings {
      */
     ShowToolTip?: boolean;
 }
+/** True when the expression AST contains a node of the given type (e.g. `CUMULATIVE`, `QUANT`). */
+export declare const expressionContainsAstNodeType: (expression: string | undefined | null, nodeType: string) => boolean;
+/**
+ * Refines an *aggregated* expression into its {@link CalculatedColumnType}
+ * category. Recognizes leftover `CUMUL` and greenfield `CUMULATIVE` /
+ * `QUANT` / window operators. Used by the v24 migration (which stamps Type
+ * before the leftover-text rewrite) and by {@link inferCalculatedColumnTypeFromExpression}.
+ */
+export declare const refineAggregatedCalculatedColumnType: (aggregated: string | undefined | null) => CalculatedColumnType;
+/**
+ * Infer {@link CalculatedColumnType} from the expression text: an aggregated
+ * category (Aggregated / Cumulative / Quantile / Window) when it contains an
+ * aggregation, `Observable` when it is per-row and contains an observable
+ * brace call (`CHANGE_COUNT{…}`, `ROW_AGE{}`, …), otherwise `Standard`.
+ * Runtime fallback when `Type` is absent.
+ */
+export declare const inferCalculatedColumnTypeFromExpression: (expression: string | undefined | null) => CalculatedColumnType;
+/**
+ * Effective Calculated Column type (`Type` or inferred from {@link CalculatedColumn.Expression}).
+ */
+export declare const getCalculatedColumnType: (calculatedColumn: Pick<CalculatedColumn, "Type" | "Expression"> | undefined | null) => CalculatedColumnType;
+/**
+ * The per-row Calculated Column types: `Standard` and `Observable` evaluate
+ * against a single row (the latter reading that row's change history); every
+ * other type aggregates over rows.
+ */
+export declare const PER_ROW_CALCULATED_COLUMN_TYPES: readonly CalculatedColumnType[];
+/** True for the per-row types ({@link PER_ROW_CALCULATED_COLUMN_TYPES}). */
+export declare const isPerRowCalculatedColumnType: (type: CalculatedColumnType) => boolean;
+/**
+ * {@link ExpressionKind} a Calculated Column of the given type is expected to
+ * hold: the per-row types (`Standard`, `Observable`) are `scalar`, every other
+ * type aggregates.
+ */
+export declare const expressionKindForCalculatedColumnType: (type: CalculatedColumnType) => ExpressionKind;
+/**
+ * Calculated Column types that support the compact live expression editor.
+ * Aggregated compact uses a Where chip + presence-based boolean chips / Functions.
+ */
+export declare const COMPACT_EXPRESSION_EDITOR_SUPPORTED_TYPES: readonly CalculatedColumnType[];
+export declare const supportsCompactExpressionEditor: (calculatedColumn: Pick<CalculatedColumn, "Type" | "Expression"> | undefined | null) => boolean;
 /**
- * Calculated Column Query which may be a Scalar or an AggregatedScalar Expression
+ * Wizard / evaluation category for a Calculated Column.
+ *
+ * - `Standard` — per-row value from other cells in the row (`[price] * [qty]`)
+ * - `Observable` — per-row value from the row's **change history**
+ *   (`CHANGE_COUNT{[price], WITHIN(5m)}`, `[price] - PREVIOUS{[price]}`,
+ *   `ROW_AGE{}`); refreshes on data changes and as time windows expire
+ * - `Aggregated` / `Cumulative` / `Quantile` / `Window` — value over a set of rows
+ *
+ * The type is an authoring lens (wizard card, editor flavour, examples);
+ * evaluation follows the expression's {@link ExpressionKind} — see
+ * {@link expressionKindForCalculatedColumnType}.
+ *
+ * Persisted on {@link CalculatedColumn.Type}. When absent (legacy state),
+ * inferred from {@link CalculatedColumn.Expression} via
+ * {@link inferCalculatedColumnTypeFromExpression}.
  */
-export type AdaptableCalculatedColumnQuery = XOR<AdaptableScalarQuery, AdaptableAggregatedScalarQuery>;
+export type CalculatedColumnType = 'Standard' | 'Observable' | 'Aggregated' | 'Cumulative' | 'Quantile' | 'Window';
+export declare const CALCULATED_COLUMN_TYPES: readonly CalculatedColumnType[];

package/src/AdaptableState/CalculatedColumnState.js

@@ -1 +1,72 @@
-export {};
+import { getAbstractSyntaxTree, walker } from "../../vendor/aql/index.js";
+import { expressionContainsAggregation, expressionContainsObservableCall, } from './Common/AdaptableQuery';
+export { expressionContainsAggregation, expressionContainsObservableCall };
+export const expressionContainsAstNodeType = (expression, nodeType) => {
+    if (!expression?.trim()) {
+        return false;
+    }
+    try {
+        const ast = getAbstractSyntaxTree(expression.trim());
+        let found = false;
+        walker(ast, (node) => {
+            if (node && typeof node === 'object' && node.type === nodeType) {
+                found = true;
+            }
+        });
+        return found;
+    }
+    catch {
+        return false;
+    }
+};
+export const refineAggregatedCalculatedColumnType = (aggregated) => {
+    if (expressionContainsAstNodeType(aggregated, 'CUMULATIVE') ||
+        expressionContainsAstNodeType(aggregated, 'CUMUL')) {
+        return 'Cumulative';
+    }
+    if (expressionContainsAstNodeType(aggregated, 'QUANT') ||
+        expressionContainsAstNodeType(aggregated, 'QUANTILE')) {
+        return 'Quantile';
+    }
+    if (expressionContainsAstNodeType(aggregated, 'LAG') ||
+        expressionContainsAstNodeType(aggregated, 'LEAD') ||
+        expressionContainsAstNodeType(aggregated, 'FIRST') ||
+        expressionContainsAstNodeType(aggregated, 'LAST') ||
+        expressionContainsAstNodeType(aggregated, 'RANK')) {
+        return 'Window';
+    }
+    return 'Aggregated';
+};
+export const inferCalculatedColumnTypeFromExpression = (expression) => {
+    if (expressionContainsAggregation(expression)) {
+        return refineAggregatedCalculatedColumnType(expression);
+    }
+    return expressionContainsObservableCall(expression) ? 'Observable' : 'Standard';
+};
+export const getCalculatedColumnType = (calculatedColumn) => calculatedColumn?.Type ?? inferCalculatedColumnTypeFromExpression(calculatedColumn?.Expression);
+export const PER_ROW_CALCULATED_COLUMN_TYPES = [
+    'Standard',
+    'Observable',
+];
+export const isPerRowCalculatedColumnType = (type) => PER_ROW_CALCULATED_COLUMN_TYPES.includes(type);
+export const expressionKindForCalculatedColumnType = (type) => (isPerRowCalculatedColumnType(type) ? 'scalar' : 'aggregated');
+export const COMPACT_EXPRESSION_EDITOR_SUPPORTED_TYPES = [
+    'Standard',
+    'Observable',
+    'Aggregated',
+    'Cumulative',
+    'Quantile',
+    'Window',
+];
+export const supportsCompactExpressionEditor = (calculatedColumn) => {
+    const type = getCalculatedColumnType(calculatedColumn);
+    return COMPACT_EXPRESSION_EDITOR_SUPPORTED_TYPES.includes(type);
+};
+export const CALCULATED_COLUMN_TYPES = [
+    'Standard',
+    'Aggregated',
+    'Observable',
+    'Cumulative',
+    'Quantile',
+    'Window',
+];

package/src/AdaptableState/Common/AdaptableAlert.d.ts

@@ -53,6 +53,14 @@ export interface AdaptableAlertBase<T> extends Identifiable {
      * Rule that caused Alert to fire
      */
     alertDefinition: AlertDefinition;
+    /**
+     * Number of individual changes this Alert represents.
+     *
+     * Normally `1`; greater than `1` when several changes from a single batch action (e.g. Bulk
+     * Update or Smart Edit) have been consolidated into a single Alert - see
+     * `AlertOptions.consolidateBatchAlerts`.
+     */
+    occurrenceCount?: number;
 }
 export declare const isAdaptableCellChangedAlert: (alert: AdaptableAlert) => alert is AdaptableCellChangedAlert;
 export declare const isAdaptableRowChangedAlert: (alert: AdaptableAlert) => alert is AdaptableRowChangedAlert;

package/src/AdaptableState/Common/AdaptableFilterState.d.ts

@@ -1,4 +1,4 @@
-import { ColumnFilter, ColumnFilterDef } from '../../types';
+import { ColumnFilter } from '../../types';
 /**
  * Current Filters in AdapTable
  */
@@ -15,8 +15,4 @@ export interface AdaptableFilterState {
      * Currently applied Column Filters
      */
     columnFilters: ColumnFilter[] | undefined;
-    /**
-     *  Column Filter definitions for currently applied Column Filters
-     */
-    columnFilterDefs: ColumnFilterDef[] | undefined;
 }

package/src/AdaptableState/Common/AdaptableIcon.d.ts

@@ -54,4 +54,4 @@ export interface AdaptableBaseIcon {
 /**
  * All AdapTable System Icon names
  */
-export type AdaptableSystemIconName = 'add' | 'alert' | 'building' | 'laptop' | 'arrow-down' | 'arrow-left' | 'arrow-right' | 'arrow-up' | 'arrow-up-long' | 'arrow-down-long' | 'arrow-expand' | 'paperclip' | 'unfilled-circle' | 'boolean-list' | 'broadcast' | 'brush' | 'spanner' | 'edit-table' | 'calculated-column' | 'calendar' | 'call' | 'cells' | 'fdc3' | 'flag' | 'chart' | 'chat' | 'check' | 'check-circle' | 'checked' | 'clone' | 'close' | 'cloud-upload' | 'collapse' | 'column-add' | 'columns' | 'filter-list' | 'copy' | 'comment' | 'comments' | 'contains' | 'dashboard' | 'json' | 'data-set' | 'date-range' | 'delete' | 'division' | 'dock' | 'dollar' | 'drag' | 'edit' | 'ends-with' | 'equals' | 'equation' | 'error' | 'excel' | 'expand' | 'exponent' | 'export' | 'export-data' | 'fast-backward' | 'fast-forward' | 'filter' | 'filter-off' | 'lightning' | 'folder' | 'folder-open' | 'folder-shared' | 'color-palette' | 'horizontal-lines' | 'function' | 'greater-than' | 'greater-than-or-equal' | 'history' | 'home' | 'import-export' | 'inspector' | 'info' | 'brain' | 'download' | 'grid' | 'interactions' | 'less-than' | 'less-than-or-equal' | 'list' | 'logout' | 'mail' | 'menu' | 'minus' | 'multiplication' | 'money' | 'newpage' | 'news' | 'filled-circle' | 'not-contains' | 'not-equal' | 'open-in-new' | 'order' | 'organisation' | 'pause' | 'percent' | 'percent-tag' | 'person' | 'contact' | 'pie-chart' | 'play' | 'plus' | 'add-circle' | 'search' | 'search-table' | 'select-all' | 'select-off' | 'select-fwd' | 'styled-grid' | 'sync' | 'quote' | 'refresh' | 'regex' | 'reminder' | 'save' | 'schedule' | 'science' | 'settings' | 'link' | 'sort-asc' | 'sort-desc' | 'spark-line' | 'resume' | 'starts-with' | 'assignment' | 'statusbar' | 'stop' | 'traffic-lights' | 'tab-unselected' | 'theme' | 'clipboard' | 'target' | 'triangle-down' | 'triangle-up' | 'unchecked' | 'undo' | 'downloaded' | 'upload' | 'warning' | 'gradient' | 'badge' | 'bullet-chart' | 'range-bar' | 'icon-style' | 'star' | 'italic' | 'bold' | 'align-left' | 'align-right' | 'align-center' | 'align-justify' | 'underline' | 'strikethrough' | 'overline' | 'case-upper' | 'case-lower' | 'case-sentence' | 'visibility-on' | 'visibility-off' | 'visibility-off-bold' | 'visibility-on-bold' | 'note' | 'import' | 'grid-filter' | 'grid-info' | 'csv' | 'rows' | 'expand-all' | 'collapse-all' | 'column-outline';
+export type AdaptableSystemIconName = 'add' | 'alert' | 'building' | 'laptop' | 'arrow-down' | 'arrow-left' | 'arrow-right' | 'arrow-up' | 'arrow-up-long' | 'arrow-down-long' | 'arrow-expand' | 'paperclip' | 'unfilled-circle' | 'boolean-list' | 'broadcast' | 'brush' | 'spanner' | 'edit-table' | 'calculated-column' | 'calendar' | 'call' | 'cells' | 'fdc3' | 'flag' | 'chart' | 'chat' | 'check' | 'check-circle' | 'checked' | 'clone' | 'close' | 'cloud-upload' | 'collapse' | 'column-add' | 'columns' | 'column-info' | 'filter-list' | 'copy' | 'comment' | 'comments' | 'contains' | 'dashboard' | 'json' | 'data-set' | 'date-range' | 'delete' | 'division' | 'dock' | 'dollar' | 'drag' | 'edit' | 'ends-with' | 'equals' | 'equation' | 'error' | 'excel' | 'expand' | 'exponent' | 'export' | 'export-data' | 'fast-backward' | 'fast-forward' | 'filter' | 'filter-off' | 'lightning' | 'folder' | 'folder-open' | 'folder-shared' | 'color-palette' | 'horizontal-lines' | 'function' | 'greater-than' | 'greater-than-or-equal' | 'history' | 'home' | 'import-export' | 'in' | 'inspector' | 'info' | 'brain' | 'download' | 'grid' | 'interactions' | 'less-than' | 'less-than-or-equal' | 'list' | 'logout' | 'mail' | 'menu' | 'minus' | 'multiplication' | 'money' | 'newpage' | 'news' | 'filled-circle' | 'not-contains' | 'not-equal' | 'not-in' | 'open-in-new' | 'order' | 'organisation' | 'pause' | 'percent' | 'percent-tag' | 'person' | 'contact' | 'pie-chart' | 'play' | 'plus' | 'add-circle' | 'plus-minus' | 'custom-sort' | 'search' | 'search-table' | 'select-all' | 'select-off' | 'select-fwd' | 'styled-grid' | 'sync' | 'quote' | 'refresh' | 'regex' | 'reminder' | 'same-day' | 'save' | 'schedule' | 'science' | 'settings' | 'shortcut' | 'link' | 'sort-asc' | 'sort-desc' | 'spark-line' | 'resume' | 'starts-with' | 'assignment' | 'statusbar' | 'stop' | 'traffic-lights' | 'tab-unselected' | 'theme' | 'clipboard' | 'tool-panel' | 'target' | 'triangle-down' | 'triangle-up' | 'unchecked' | 'undo' | 'downloaded' | 'upload' | 'warning' | 'gradient' | 'badge' | 'bullet-chart' | 'range-bar' | 'icon-style' | 'star' | 'italic' | 'bold' | 'align-left' | 'align-right' | 'align-center' | 'align-justify' | 'underline' | 'strikethrough' | 'overline' | 'case-upper' | 'case-lower' | 'case-sentence' | 'visibility-on' | 'visibility-off' | 'visibility-off-bold' | 'visibility-on-bold' | 'note' | 'import' | 'grid-filter' | 'grid-info' | 'csv' | 'rows' | 'expand-all' | 'collapse-all' | 'column-outline';

package/src/AdaptableState/Common/AdaptableObject.d.ts

@@ -32,7 +32,7 @@ export interface AdaptableObject extends Identifiable {
      */
     IsReadOnly?: boolean;
     /**
-     * List of Tags associated with the Object; often used for extending Layouts
+     * List of Tags associated with the Object
      */
     Tags?: AdaptableObjectTag[];
     /**

package/src/AdaptableState/Common/AdaptableQuery.d.ts

@@ -1,51 +1,55 @@
-import { XOR } from '../../Utilities/Extensions/TypeExtensions';
 /**
- * Wraps an AdapTableQL Boolean Expression
+ * Evaluation strategy of an AdapTableQL Expression, inferred from its text:
+ *
+ * - `scalar` — evaluated per row (e.g. `[price] > 100`, `[qty] * [price]`)
+ * - `aggregated` — evaluated over a set of rows (e.g. `SUM{[notional]} > 1000000`,
+ *   `AVG{[price], GROUP_BY([sector])}`)
+ *
+ * Live (observable) functions (`CHANGE_COUNT{[price], WITHIN(5m)} >= 3`,
+ * `ROW_AGE{}`) read the row's own change history and are `scalar`.
+ *
+ * Kind is a property of the syntax: `NAME(...)` is a per-row function call,
+ * `NAME{...}` is a set call. State objects therefore store expressions as
+ * plain strings and AdapTable infers the kind.
  */
-export interface AdaptableBooleanQuery {
-    /**
-     * AdapTableQL Expression that returns true / false
-     */
-    BooleanExpression: string;
-}
+export type ExpressionKind = 'scalar' | 'aggregated';
 /**
- * Wraps an AdapTableQL Scalar Expression
+ * An expression string paired with its inferred {@link ExpressionKind}.
+ * Internal representation used by the modules whose evaluation strategy
+ * depends on the kind (Alert, Calculated Column).
  */
-export interface AdaptableScalarQuery {
-    /**
-     * AdapTableQL Expression that returns any value
-     */
-    ScalarExpression: string;
+export interface ResolvedExpression {
+    kind: ExpressionKind;
+    text: string;
 }
-/**
- * Wraps an AdapTableQL Observable Expression
- */
-export interface AdaptableObservableQuery {
-    /**
-     * AdapTableQL Expression that observes the Grid or given rows
-     */
-    ObservableExpression: string;
+export interface InferExpressionKindOptions {
+    /** Custom aggregation (brace-call) names registered by the host. */
+    customAggregatedNames?: Iterable<string>;
 }
 /**
- * Wraps an AdapTableQL Aggregated Boolean Expression
+ * Infers the {@link ExpressionKind} from the expression text alone.
+ * Returns `undefined` for empty or unparseable text.
+ *
+ * Pure and host-agnostic: brace syntax marks aggregation regardless of the
+ * name. At runtime prefer `queryLanguageService.getExpressionKind`,
+ * which supplies the module's custom names and memoises the result.
  */
-export interface AdaptableAggregatedBooleanQuery {
-    /**
-     * AdapTableQL Expression that returns true / false based on multiple rows
-     */
-    AggregatedBooleanExpression: string;
-}
+export declare const inferExpressionKindFromText: (expression: string | undefined | null, options?: InferExpressionKindOptions) => ExpressionKind | undefined;
 /**
- * Wraps an AdapTableQL Aggregated Scalar Expression
+ * True when the expression text contains an aggregation — a brace call
+ * (`SUM{...}`, custom aggregations included) or one of the paren-form
+ * aggregation wrappers (`PERCENTAGE(...)`, `CUMUL(...)`, …). Observable brace
+ * calls (`CHANGE_COUNT{...}`) are **not** aggregations: the check runs on the
+ * normalized program, where the parser's generic brace-call kind has been
+ * split into `AGG_CALL` / `OBSERVABLE_CALL`. Empty or unparseable text → false.
  */
-export interface AdaptableAggregatedScalarQuery {
-    /**
-     * AdapTableQL Expression that returns any value based on multiple rows
-     */
-    AggregatedScalarExpression: string;
-}
+export declare const expressionContainsAggregation: (expression: string | undefined | null, options?: InferExpressionKindOptions) => boolean;
 /**
- * An AdaptableQuery can be either a Boolean, Scalar, Observable, AggregatedBoolean, or AggregatedScalar expression
+ * True when the expression text contains an observable brace call
+ * (`CHANGE_COUNT{[price], WITHIN(5m)}`, `PREVIOUS{[c]}`, `ROW_AGE{}`, …) at
+ * any depth. The dual-name paren spelling `PERCENT_CHANGE([c])` is a
+ * data-change scalar, not an observable call. Clock reads (`NOW()`) are not
+ * observable calls either — callers that need "live" use the compiled
+ * dependencies. Empty or unparseable text → false.
  */
-export type AdaptableQuery = XOR<AdaptableBooleanQuery, XOR<AdaptableScalarQuery, XOR<AdaptableObservableQuery, XOR<AdaptableAggregatedBooleanQuery, AdaptableAggregatedScalarQuery>>>>;
-export declare const isReactiveQuery: (query: Partial<AdaptableQuery>) => boolean;
+export declare const expressionContainsObservableCall: (expression: string | undefined | null, options?: InferExpressionKindOptions) => boolean;

package/src/AdaptableState/Common/AdaptableQuery.js

@@ -1,3 +1,26 @@
-export const isReactiveQuery = (query) => {
-    return !!query.ObservableExpression;
+import { classifyExpression, inferExpressionKind, normalizeAst, parse } from "../../../vendor/aql/index.js";
+export const inferExpressionKindFromText = (expression, options) => {
+    const text = typeof expression === 'string' ? expression.trim() : '';
+    if (text === '') {
+        return undefined;
+    }
+    try {
+        return inferExpressionKind(normalizeAst(parse(text).ast, options));
+    }
+    catch {
+        return undefined;
+    }
+};
+export const expressionContainsAggregation = (expression, options) => inferExpressionKindFromText(expression, options) === 'aggregated';
+export const expressionContainsObservableCall = (expression, options) => {
+    const text = typeof expression === 'string' ? expression.trim() : '';
+    if (text === '') {
+        return false;
+    }
+    try {
+        return classifyExpression(normalizeAst(parse(text).ast, options)).observableCallCount > 0;
+    }
+    catch {
+        return false;
+    }
 };

package/src/AdaptableState/Common/AlternativeModuleIcon.d.ts

@@ -0,0 +1,16 @@
+import { AdaptableModule } from '../../types';
+import { AdaptableIcon } from './AdaptableIcon';
+/**
+ * Defines a replacement icon for an Adaptable Module (Settings Panel, Dashboard /
+ * Tool Panel buttons, Status Bar, menus, etc.).
+ */
+export interface AlternativeModuleIcon {
+    /**
+     * Adaptable Module whose icon to replace
+     */
+    adaptableModule: AdaptableModule;
+    /**
+     * Icon to use instead of the Module's default Glyph
+     */
+    newIcon: AdaptableIcon;
+}

package/src/AdaptableState/Common/CellDataChangedInfo.d.ts

@@ -33,10 +33,12 @@ export interface CellDataChangedInfo<TData = any> {
      */
     rowData?: TData;
     /**
-     * What triggered the change - user, background change, a reverted change, or a
-     * derived update on a Calculated Column whose source value changed?
+     * What triggered the change - user, background change, a reverted change, a
+     * derived update on a Calculated Column whose source value changed, or a
+     * live Alert rule turning true for the row (`live`: no old / new value,
+     * `column` is the rule's first Scope column when it has one).
      */
-    trigger?: 'edit' | 'tick' | 'undo' | 'aggChange' | 'calculatedColumnChange';
+    trigger?: 'edit' | 'tick' | 'undo' | 'aggChange' | 'calculatedColumnChange' | 'live';
     /**
      * Whether the change was prevented by a validation rule
      */