@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.1

package/src/components/aql/ExpressionEditor/aqlHover.js

@@ -0,0 +1,320 @@
+import { CLAUSE_OPERAND_KINDS, getTokens, } from "../../../../vendor/aql/index.js";
+import { collectColumnRefHighlightParts } from '../../../aql/formulaTraceUtils';
+import { CHIP_COLUMN_PLACEHOLDER_MESSAGE, CHIP_DURATION_PLACEHOLDER, CHIP_DURATION_PLACEHOLDER_MESSAGE, isChipColumnPlaceholder, } from '../../../aql/chipColumnPlaceholder';
+import { editorButtonsSearch } from './editorButtonsSearch';
+import { CLAUSE_DOCS, resolveBraceCallSpec } from './aqlCompletionTypeContext';
+const SYMBOL_TO_FUNCTION = (() => {
+    const map = {};
+    for (const button of editorButtonsSearch) {
+        if (button.functionName && button.data) {
+            map[button.data] = button.functionName;
+        }
+    }
+    return map;
+})();
+const KEYWORD_FUNCTION_NAMES = new Set(['CASE', 'AND', 'OR', 'IN', 'WHERE', 'TRUE', 'FALSE']);
+const DEDICATED_OPERAND_NAMES = new Set(Object.keys(CLAUSE_OPERAND_KINDS).filter((clause) => clause !== 'WHERE'));
+function formatColumnDataType(dataType) {
+    if (!dataType) {
+        return undefined;
+    }
+    return dataType.charAt(0).toUpperCase() + dataType.slice(1);
+}
+function describeColumnKind(column) {
+    const parts = [];
+    if (column.isPrimaryKey) {
+        parts.push('Primary Key');
+    }
+    if (column.isCalculatedColumn) {
+        parts.push('Calculated Column');
+    }
+    else if (column.isFreeTextColumn) {
+        parts.push('Free Text Column');
+    }
+    return parts.length ? parts.join(' · ') : undefined;
+}
+export function resolveAqlHoverTarget(docText, pos) {
+    for (const part of collectColumnRefHighlightParts(docText)) {
+        if (pos >= part.openStart && pos <= part.closeEnd) {
+            return {
+                kind: 'column',
+                columnId: part.columnId,
+                from: part.openStart,
+                to: part.closeEnd,
+            };
+        }
+    }
+    const leadingWs = docText.length - docText.trimStart().length;
+    const trimmed = docText.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const adj = pos - leadingWs;
+    if (adj < 0 || adj > trimmed.length) {
+        return null;
+    }
+    let tokens = [];
+    try {
+        tokens = getTokens(trimmed);
+    }
+    catch {
+        return null;
+    }
+    const token = tokens.find((candidate) => {
+        const [from, to] = candidate.range;
+        return adj >= from && adj <= to;
+    });
+    if (!token) {
+        return null;
+    }
+    const from = leadingWs + token.range[0];
+    const to = leadingWs + token.range[1];
+    if (token.type === 'FUNCTION' && token.value) {
+        const tokenIndex = tokens.indexOf(token);
+        const next = tokens[tokenIndex + 1];
+        const name = token.value.toUpperCase();
+        const bracket = next?.type === '{' ? 'brace' : next?.type === '(' ? 'paren' : undefined;
+        if (DEDICATED_OPERAND_NAMES.has(name) && bracket === 'paren') {
+            return {
+                kind: 'function',
+                functionName: name,
+                from,
+                to,
+                bracket,
+                staticDocs: {
+                    title: name,
+                    body: CLAUSE_DOCS[name],
+                },
+            };
+        }
+        return { kind: 'function', functionName: token.value, from, to, bracket };
+    }
+    const symbolName = SYMBOL_TO_FUNCTION[token.value] ?? SYMBOL_TO_FUNCTION[token.type];
+    if (symbolName) {
+        return { kind: 'function', functionName: symbolName, from, to };
+    }
+    if (token.type === 'DURATION_PLACEHOLDER' || token.value === CHIP_DURATION_PLACEHOLDER) {
+        return {
+            kind: 'function',
+            functionName: 'DURATION_PLACEHOLDER',
+            from,
+            to,
+            staticDocs: {
+                title: CHIP_DURATION_PLACEHOLDER,
+                body: CHIP_DURATION_PLACEHOLDER_MESSAGE,
+            },
+        };
+    }
+    if (token.type === 'DURATION') {
+        return {
+            kind: 'function',
+            functionName: 'DURATION',
+            from,
+            to,
+            staticDocs: {
+                title: token.value,
+                body: 'Duration literal — units: ms (milliseconds), s (seconds), m (minutes), h (hours), d (days)',
+            },
+        };
+    }
+    if (KEYWORD_FUNCTION_NAMES.has(token.type)) {
+        return { kind: 'function', functionName: token.type, from, to };
+    }
+    return null;
+}
+function readDocs(source) {
+    if (!source || typeof source !== 'object') {
+        return null;
+    }
+    const fn = source;
+    return {
+        label: typeof fn.label === 'string' ? fn.label : undefined,
+        returnType: typeof fn.returnType === 'string' ? fn.returnType : undefined,
+        description: typeof fn.description === 'string' ? fn.description : undefined,
+        signatures: Array.isArray(fn.signatures)
+            ? fn.signatures.filter((item) => typeof item === 'string')
+            : undefined,
+        examples: Array.isArray(fn.examples)
+            ? fn.examples.filter((item) => typeof item === 'string')
+            : undefined,
+    };
+}
+function appendSection(parent, title, body, asCode = false) {
+    const section = document.createElement('div');
+    section.className = 'ab-AqlCodeMirror__hover-section';
+    const heading = document.createElement('div');
+    heading.className = 'ab-AqlCodeMirror__hover-heading';
+    heading.textContent = title;
+    section.appendChild(heading);
+    const content = document.createElement(asCode ? 'pre' : 'div');
+    content.className = asCode
+        ? 'ab-AqlCodeMirror__hover-code'
+        : 'ab-AqlCodeMirror__hover-text';
+    content.textContent = body;
+    section.appendChild(content);
+    parent.appendChild(section);
+}
+function buildStaticHoverDom(staticDocs) {
+    const root = document.createElement('div');
+    root.className = 'ab-AqlCodeMirror__hover';
+    root.setAttribute('data-name', 'aql-expression-hover');
+    const header = document.createElement('div');
+    header.className = 'ab-AqlCodeMirror__hover-header';
+    const nameEl = document.createElement('span');
+    nameEl.className = 'ab-AqlCodeMirror__hover-name';
+    nameEl.textContent = staticDocs.title;
+    header.appendChild(nameEl);
+    root.appendChild(header);
+    const body = document.createElement('div');
+    body.className = 'ab-AqlCodeMirror__hover-text';
+    body.textContent = staticDocs.body;
+    root.appendChild(body);
+    return root;
+}
+function buildColumnHoverDom(columnId, columns) {
+    if (isChipColumnPlaceholder(columnId)) {
+        const root = document.createElement('div');
+        root.className = 'ab-AqlCodeMirror__hover ab-AqlCodeMirror__hover--column';
+        root.setAttribute('data-name', 'aql-expression-hover');
+        const header = document.createElement('div');
+        header.className = 'ab-AqlCodeMirror__hover-header';
+        const nameEl = document.createElement('span');
+        nameEl.className = 'ab-AqlCodeMirror__hover-name ab-AqlCodeMirror__hover-name--column';
+        nameEl.textContent = columnId;
+        header.appendChild(nameEl);
+        const role = document.createElement('span');
+        role.className = 'ab-AqlCodeMirror__hover-notation';
+        role.textContent = 'Placeholder';
+        header.appendChild(role);
+        root.appendChild(header);
+        const hint = document.createElement('div');
+        hint.className = 'ab-AqlCodeMirror__hover-text';
+        hint.textContent = CHIP_COLUMN_PLACEHOLDER_MESSAGE;
+        root.appendChild(hint);
+        return root;
+    }
+    const meta = columns?.find((column) => column.columnId === columnId);
+    const friendlyName = meta?.friendlyName?.trim() || columnId;
+    const dataType = formatColumnDataType(meta?.dataType);
+    const kind = meta ? describeColumnKind(meta) : undefined;
+    const root = document.createElement('div');
+    root.className = 'ab-AqlCodeMirror__hover ab-AqlCodeMirror__hover--column';
+    root.setAttribute('data-name', 'aql-expression-hover');
+    const header = document.createElement('div');
+    header.className = 'ab-AqlCodeMirror__hover-header';
+    const nameEl = document.createElement('span');
+    nameEl.className = 'ab-AqlCodeMirror__hover-name ab-AqlCodeMirror__hover-name--column';
+    nameEl.textContent = friendlyName;
+    header.appendChild(nameEl);
+    const role = document.createElement('span');
+    role.className = 'ab-AqlCodeMirror__hover-notation';
+    role.textContent = 'Column';
+    header.appendChild(role);
+    if (dataType) {
+        const typeEl = document.createElement('span');
+        typeEl.className = 'ab-AqlCodeMirror__hover-return-type';
+        typeEl.textContent = dataType;
+        header.appendChild(typeEl);
+    }
+    root.appendChild(header);
+    if (friendlyName !== columnId) {
+        appendSection(root, 'Column Id', columnId, true);
+    }
+    if (dataType) {
+        appendSection(root, 'Data Type', dataType);
+    }
+    if (kind) {
+        appendSection(root, 'Kind', kind);
+    }
+    if (!meta) {
+        const hint = document.createElement('div');
+        hint.className = 'ab-AqlCodeMirror__hover-text';
+        hint.textContent = 'This column id was not found in the current grid.';
+        root.appendChild(hint);
+    }
+    return root;
+}
+export function describeBraceCallClauses(functionName, catalogue) {
+    const spec = resolveBraceCallSpec(functionName, undefined, catalogue);
+    if (!spec?.clauses.length) {
+        return null;
+    }
+    return spec.clauses
+        .map(({ clause, required }) => {
+        const label = clause;
+        return required ? `${label} (required)` : label;
+    })
+        .join(', ');
+}
+export function buildAqlHoverTooltipDom(target, expressionFunctions, scalarExpressionFunctions, catalogue, columns) {
+    if (typeof target !== 'string' && target.kind === 'column') {
+        return buildColumnHoverDom(target.columnId, columns);
+    }
+    if (typeof target !== 'string' && target.staticDocs) {
+        return buildStaticHoverDom(target.staticDocs);
+    }
+    const functionName = typeof target === 'string' ? target : target.functionName;
+    const bracket = typeof target === 'string' ? undefined : target.bracket;
+    const docsSource = bracket === 'paren' && scalarExpressionFunctions?.[functionName]
+        ? scalarExpressionFunctions[functionName]
+        : expressionFunctions?.[functionName];
+    const docs = readDocs(docsSource);
+    if (!docs && !docsSource) {
+        return null;
+    }
+    const root = document.createElement('div');
+    root.className = 'ab-AqlCodeMirror__hover';
+    root.setAttribute('data-name', 'aql-expression-hover');
+    const header = document.createElement('div');
+    header.className = 'ab-AqlCodeMirror__hover-header';
+    const nameEl = document.createElement('span');
+    nameEl.className = 'ab-AqlCodeMirror__hover-name';
+    nameEl.textContent = functionName;
+    header.appendChild(nameEl);
+    const notation = Object.entries(SYMBOL_TO_FUNCTION).find(([, name]) => name === functionName)?.[0];
+    if (notation && notation !== functionName) {
+        const note = document.createElement('span');
+        note.className = 'ab-AqlCodeMirror__hover-notation';
+        note.textContent = notation;
+        note.title = `Also written as ${notation}`;
+        header.appendChild(note);
+    }
+    if (docs?.label && docs.label !== functionName) {
+        const label = document.createElement('span');
+        label.className = 'ab-AqlCodeMirror__hover-label';
+        label.textContent = docs.label;
+        header.appendChild(label);
+    }
+    if (docs?.returnType) {
+        const ret = document.createElement('span');
+        ret.className = 'ab-AqlCodeMirror__hover-return-type';
+        ret.textContent = docs.returnType;
+        header.appendChild(ret);
+    }
+    root.appendChild(header);
+    if (docs?.description) {
+        const body = document.createElement('div');
+        body.className = 'ab-AqlCodeMirror__hover-text';
+        body.textContent = docs.description;
+        root.appendChild(body);
+    }
+    if (docs?.signatures?.length) {
+        appendSection(root, 'Signatures', docs.signatures[0], true);
+    }
+    const clauseInventory = describeBraceCallClauses(functionName, catalogue);
+    if (clauseInventory) {
+        appendSection(root, 'Clauses', clauseInventory);
+    }
+    if (docs?.examples?.length) {
+        appendSection(root, 'Examples', docs.examples[0], true);
+    }
+    if (root.childElementCount <= 1 &&
+        !docs?.description &&
+        !docs?.signatures?.length) {
+        const hint = document.createElement('div');
+        hint.className = 'ab-AqlCodeMirror__hover-text';
+        hint.textContent = 'No documentation available for this function.';
+        root.appendChild(hint);
+    }
+    return root;
+}

package/src/components/aql/ExpressionEditor/aqlLint.d.ts

@@ -0,0 +1,45 @@
+import { type AggregationCatalogue } from "../../../../vendor/aql/index.js";
+import { type LegacyExpressionKind } from '../../../aql/legacyExpressionKinds';
+import type { Diagnostic } from '@codemirror/lint';
+export type AqlLintFunctionMap = Record<string, unknown>;
+export type AqlLintColumn = {
+    columnId: string;
+    dataType?: string;
+};
+/**
+ * Editor lint configuration: which pools / kind the surface authors against.
+ * Built once per editor surface (see `buildAqlEditorLintContext`) and shared
+ * by the CodeMirror linter and the error boxes under the editor.
+ */
+export type AqlEditorLintContext = {
+    /** The legacy five-kind binding of this editor surface. */
+    legacyKind?: LegacyExpressionKind;
+    /** Scalar pool — enables unknown-name checks and the type walk. */
+    scalarFunctions?: AqlLintFunctionMap;
+    /**
+     * The module's aggregation catalogue (system + custom operators with their
+     * derived clause support). Defaults to the system catalogue.
+     */
+    catalogue?: AggregationCatalogue;
+    /** Rail 9: maximum `WITHIN` window in ms. */
+    maxWithinMs?: number;
+    /** `LAST_N(n)` ceiling — the per-cell history ring buffer size. */
+    maxHistoryPerCell?: number;
+    /**
+     * Whether this surface's module evaluates against the live grid and may
+     * therefore spell observable (live) brace calls; `false` flags them.
+     */
+    allowsObservableCalls?: boolean;
+};
+/**
+ * Build CodeMirror lint diagnostics for an AQL expression: parse errors,
+ * then the aql structural validation (guard rails, bracket-aware unknown
+ * names, clause/operand checks, type walk) with quick-fix payloads exposed
+ * as CodeMirror diagnostic actions.
+ *
+ * Empty / whitespace-only docs produce no marks (avoid noise while clearing).
+ */
+export declare function buildAqlLintDiagnostics(docText: string, options?: AqlEditorLintContext & {
+    /** Column catalog for static type checks and AdapTable missing-column errors. */
+    columns?: AqlLintColumn[];
+}): Diagnostic[];

package/src/components/aql/ExpressionEditor/aqlLint.js

@@ -0,0 +1,138 @@
+import { mapDataTypeToStaticType, parse, validateAqlExpression, } from "../../../../vendor/aql/index.js";
+import { mapLegacyKindToValidationRequest, } from '../../../aql/legacyExpressionKinds';
+import { getMissingColumnIssues } from '../../../aql/getMissingColumnIssues';
+export function buildAqlLintDiagnostics(docText, options) {
+    const leadingWs = docText.length - docText.trimStart().length;
+    const trimmed = docText.trim();
+    if (!trimmed) {
+        return [];
+    }
+    let ast;
+    try {
+        ({ ast } = parse(trimmed));
+    }
+    catch (error) {
+        const message = formatParseErrorMessage(error);
+        const range = getParseErrorRange(error, trimmed.length);
+        return [
+            {
+                from: Math.min(leadingWs + range.from, docText.length),
+                to: Math.min(leadingWs + range.to, docText.length),
+                severity: 'error',
+                message,
+            },
+        ];
+    }
+    const getColumnType = buildGetColumnType(options?.columns);
+    const legacyKind = options?.legacyKind;
+    const validationOptions = {
+        request: legacyKind
+            ? {
+                ...mapLegacyKindToValidationRequest(legacyKind),
+                requiresAggCalls: false,
+                allowsObservableCalls: options?.allowsObservableCalls,
+            }
+            : options?.allowsObservableCalls === false
+                ? { allowsObservableCalls: false }
+                : undefined,
+        scalarFunctions: options?.scalarFunctions,
+        catalogue: options?.catalogue,
+        maxWithinMs: options?.maxWithinMs,
+        maxHistoryPerCell: options?.maxHistoryPerCell,
+        getColumnType,
+    };
+    const result = validateAqlExpression(ast, validationOptions);
+    const diagnostics = [];
+    for (const issue of result.issues) {
+        diagnostics.push(toDiagnostic(issue, leadingWs, trimmed.length, docText.length));
+    }
+    const knownColumnIds = options?.columns?.length
+        ? new Set(options.columns.map((column) => column.columnId))
+        : null;
+    if (knownColumnIds) {
+        for (const issue of getMissingColumnIssues(result.normalizedAst, (columnId) => knownColumnIds.has(columnId))) {
+            const from = issue.range?.[0] ?? 0;
+            const to = issue.range?.[1] ?? trimmed.length;
+            diagnostics.push({
+                from: leadingWs + from,
+                to: leadingWs + Math.max(from + 1, to),
+                severity: issue.severity,
+                message: issue.message,
+            });
+        }
+    }
+    return diagnostics;
+}
+function toDiagnostic(issue, leadingWs, trimmedLength, docLength) {
+    const from = issue.range?.[0] ?? 0;
+    const to = issue.range?.[1] ?? trimmedLength;
+    const diagnostic = {
+        from: Math.min(leadingWs + from, docLength),
+        to: Math.min(leadingWs + Math.max(from + 1, to), docLength),
+        severity: issue.severity,
+        message: issue.message,
+    };
+    const quickFix = issue.quickFix;
+    if (quickFix) {
+        const [fixFrom, fixTo] = quickFix.range ?? issue.range ?? [0, trimmedLength];
+        diagnostic.actions = [
+            {
+                name: quickFix.label,
+                apply: (view) => {
+                    view.dispatch({
+                        changes: {
+                            from: Math.min(leadingWs + fixFrom, view.state.doc.length),
+                            to: Math.min(leadingWs + fixTo, view.state.doc.length),
+                            insert: quickFix.replacement,
+                        },
+                    });
+                },
+            },
+        ];
+    }
+    return diagnostic;
+}
+function buildGetColumnType(columns) {
+    if (!columns?.length) {
+        return undefined;
+    }
+    const types = new Map();
+    for (const column of columns) {
+        types.set(column.columnId, mapDataTypeToStaticType(column.dataType));
+    }
+    return (columnId) => types.get(columnId);
+}
+function formatParseErrorMessage(error) {
+    if (typeof error?.message === 'string' && error.message.trim()) {
+        const lines = error.message
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const expecting = lines.find((line) => /^Expecting\b/i.test(line));
+        if (expecting) {
+            return expecting;
+        }
+        return lines[0] || 'Invalid expression';
+    }
+    return 'Invalid expression';
+}
+function getParseErrorRange(error, trimmedLength) {
+    const range = error?.hash?.loc?.range;
+    if (Array.isArray(range) && range.length >= 2) {
+        let from = Number(range[0]);
+        let to = Number(range[1]);
+        if (!Number.isFinite(from) || !Number.isFinite(to)) {
+            return { from: 0, to: trimmedLength };
+        }
+        from = Math.max(0, Math.min(from, trimmedLength));
+        to = Math.max(from, Math.min(to, trimmedLength));
+        if (to <= from) {
+            to = Math.min(trimmedLength, from + 1);
+        }
+        if (from === to && from > 0) {
+            from = from - 1;
+        }
+        return { from, to };
+    }
+    return { from: Math.max(0, trimmedLength - 1), to: trimmedLength };
+}

package/src/components/aql/ExpressionEditor/booleanEditorHostError.d.ts

@@ -0,0 +1,16 @@
+import type { LegacyExpressionKind } from '../../../aql/legacyExpressionKinds';
+import type { AdaptableApi } from '../../../Api/AdaptableApi';
+import type { AdaptableModule } from '../../../AdaptableState/Common/Types';
+/**
+ * Apply / Save use `validateBoolean`. Lint can stay silent for `any`-typed
+ * roots (IF, COALESCE, numeric QUERY). This is the message to show when the
+ * gate fails and the expression is a non-empty boolean-editor document.
+ */
+export declare function resolveBooleanEditorHostError(args: {
+    expression: string | undefined;
+    legacyKind?: LegacyExpressionKind;
+    api: AdaptableApi;
+    module: AdaptableModule;
+}): string | undefined;
+/** Host message only when parse / eval / lint did not already explain the failure. */
+export declare function shouldDisplayHostValidationError(hostError: string | undefined, hasLintOrParseOrEvalError: boolean): boolean;

package/src/components/aql/ExpressionEditor/booleanEditorHostError.js

@@ -0,0 +1,20 @@
+export function resolveBooleanEditorHostError(args) {
+    if (args.legacyKind !== 'boolean') {
+        return undefined;
+    }
+    const trimmed = (args.expression ?? '').trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const result = args.api.internalApi
+        .getQueryLanguageService()
+        .validateBoolean(trimmed, args.module, { force: true });
+    if (result.isValid) {
+        return undefined;
+    }
+    const message = String(result.errorMessage ?? '').trim();
+    return message || undefined;
+}
+export function shouldDisplayHostValidationError(hostError, hasLintOrParseOrEvalError) {
+    return Boolean(hostError) && !hasLintOrParseOrEvalError;
+}

package/src/components/aql/ExpressionEditor/changeFunctionMenus.d.ts

@@ -0,0 +1,8 @@
+import type { ExtraFunctionMenu } from './BaseEditorInput';
+/** Scalar change functions — need `dataChangedEvent` (Relative Change / Flashing Cell). */
+export declare const DATA_CHANGE_EXPRESSION_FUNCTION_NAMES: readonly ["ANY_CHANGE", "PERCENT_CHANGE", "ABSOLUTE_CHANGE"];
+/**
+ * Leading Change menu for Relative Change alerts / Flashing Cell.
+ * INCREASE / DECREASE are string literals (toolbar chips), not AQL functions.
+ */
+export declare const CHANGE_EXPRESSION_FUNCTION_MENUS: ExtraFunctionMenu[];

package/src/components/aql/ExpressionEditor/changeFunctionMenus.js

@@ -0,0 +1,12 @@
+export const DATA_CHANGE_EXPRESSION_FUNCTION_NAMES = [
+    'ANY_CHANGE',
+    'PERCENT_CHANGE',
+    'ABSOLUTE_CHANGE',
+];
+export const CHANGE_EXPRESSION_FUNCTION_MENUS = [
+    {
+        id: 'change',
+        label: 'Change',
+        functionNames: [...DATA_CHANGE_EXPRESSION_FUNCTION_NAMES],
+    },
+];

package/src/components/aql/ExpressionEditor/chipInsertPlaceholders.d.ts

@@ -0,0 +1 @@
+export { CHIP_COLUMN_PLACEHOLDER, CHIP_COLUMN_PLACEHOLDER_MESSAGE, CHIP_COLUMN_PLACEHOLDER_TOKEN, CHIP_DURATION_PLACEHOLDER, CHIP_DURATION_PLACEHOLDER_MESSAGE, isChipColumnPlaceholder, isChipDurationPlaceholder, } from '../../../aql/chipColumnPlaceholder';

package/src/components/aql/ExpressionEditor/chipInsertPlaceholders.js

@@ -0,0 +1 @@
+export { CHIP_COLUMN_PLACEHOLDER, CHIP_COLUMN_PLACEHOLDER_MESSAGE, CHIP_COLUMN_PLACEHOLDER_TOKEN, CHIP_DURATION_PLACEHOLDER, CHIP_DURATION_PLACEHOLDER_MESSAGE, isChipColumnPlaceholder, isChipDurationPlaceholder, } from '../../../aql/chipColumnPlaceholder';

package/src/components/aql/ExpressionEditor/diffRelativeUtils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Helpers for Aggregated Calculated Column expressions that use
+ * ABSOLUTE_DIFF / PERCENT_DIFF — those wrappers accept LAG / LEAD / FIRST /
+ * LAST as relatives, so the Aggregated editor can surface Window chips when
+ * a Diff is present (UI only; no AQL changes).
+ *
+ * See also WHERE chip gating in EditorInputWithWhereClause / EditorInput
+ * (compact Aggregated).
+ */
+/** Function names that unlock Diff window-relative chips. */
+export declare const DIFF_WRAPPER_FUNCTION_NAMES: readonly ["ABSOLUTE_DIFF", "PERCENT_DIFF"];
+export type DiffWrapperFunctionName = (typeof DIFF_WRAPPER_FUNCTION_NAMES)[number];
+/** Window relatives Diff accepts (RANK is Window-only, not a Diff relative). */
+export declare const DIFF_WINDOW_RELATIVE_FUNCTION_NAMES: readonly ["LAG", "LEAD", "FIRST", "LAST", "OVER"];
+export type DiffWindowRelativeFunctionName = (typeof DIFF_WINDOW_RELATIVE_FUNCTION_NAMES)[number];
+/** True when the expression mentions ABSOLUTE_DIFF or PERCENT_DIFF. */
+export declare function expressionHasDiffWrapper(expression: string): boolean;

package/src/components/aql/ExpressionEditor/diffRelativeUtils.js

@@ -0,0 +1,12 @@
+export const DIFF_WRAPPER_FUNCTION_NAMES = ['ABSOLUTE_DIFF', 'PERCENT_DIFF'];
+export const DIFF_WINDOW_RELATIVE_FUNCTION_NAMES = [
+    'LAG',
+    'LEAD',
+    'FIRST',
+    'LAST',
+    'OVER',
+];
+const DIFF_WRAPPER_RE = /\b(?:ABSOLUTE_DIFF|PERCENT_DIFF)\b/;
+export function expressionHasDiffWrapper(expression) {
+    return DIFF_WRAPPER_RE.test(expression ?? '');
+}

package/src/components/aql/ExpressionEditor/editorButtonsAggregatedBoolean.d.ts

@@ -0,0 +1,7 @@
+import { OperatorEditorButton } from './BaseEditorInput';
+/**
+ * Alert Aggregated (boolean) toolbar: the consolidated value chips (pool-gated),
+ * then comparison operators.
+ * `expressionOptions.expressionEditorButtons` still uses `editorType: 'aggregated'`.
+ */
+export declare const editorButtonsAggregatedBoolean: OperatorEditorButton[];

package/src/components/aql/ExpressionEditor/editorButtonsAggregatedBoolean.js

@@ -0,0 +1,37 @@
+import { editorButtonsValue } from './editorButtonsValue';
+const COMPARISON_EDITOR_BUTTONS = [
+    {
+        functionName: 'EQ',
+        data: '=',
+        icon: 'equals',
+    },
+    {
+        functionName: 'NEQ',
+        data: '!=',
+        icon: 'not-equal',
+    },
+    {
+        functionName: 'LT',
+        data: '<',
+        icon: 'less-than',
+    },
+    {
+        functionName: 'GT',
+        data: '>',
+        icon: 'greater-than',
+    },
+    {
+        functionName: 'LTE',
+        data: '<=',
+        icon: 'less-than-or-equal',
+    },
+    {
+        functionName: 'GTE',
+        data: '>=',
+        icon: 'greater-than-or-equal',
+    },
+];
+export const editorButtonsAggregatedBoolean = [
+    ...editorButtonsValue.map((button, index, list) => index === list.length - 1 ? { ...button, newRowAfter: true } : button),
+    ...COMPARISON_EDITOR_BUTTONS,
+];

package/src/components/aql/ExpressionEditor/editorButtonsObservable.d.ts

@@ -0,0 +1,14 @@
+import { OperatorEditorButton } from './BaseEditorInput';
+/**
+ * Observable skeleton chips for scalar editors: each inserts a complete,
+ * valid brace call with placeholders for the column and (when needed) the
+ * window so a user can author every catalogue expression without typing a
+ * function name. Chips are pool-gated by `BaseEditorInput`, so they appear
+ * only where the module policy offers the observable pool (Calculated
+ * Column, Format Column, Flashing Cell, Alert).
+ *
+ * Clause chips (`ANY_COL` / `WITHIN` / `LAST_N` / `ALL_ROWS` / `TRIGGER` / `WHERE`) are not
+ * listed here: they come from the caret-adaptive clause strip once the caret
+ * sits inside a brace call.
+ */
+export declare const editorButtonsObservable: OperatorEditorButton[];