@adaptabletools/adaptable 24.0.0-canary.1 → 24.0.0-canary.10

package/agGrid.d.ts

@@ -1,4 +1,4 @@
-import Adaptable, { AdaptableWizardView } from './src/agGrid';
+import Adaptable from './src/agGrid';
 import { AdaptableAgGrid } from './src/agGrid/AdaptableAgGrid';
 import { AdaptableNumberEditor, AdaptableReactNumberEditor } from './src/agGrid/editors/AdaptableNumberEditor';
 import { AdaptablePercentageEditor, AdaptableReactPercentageEditor } from './src/agGrid/editors/AdaptablePercentageEditor';
@@ -8,7 +8,6 @@ import { AdaptableUpgradeHelper, type UpgradeConfig } from './src/migration/Adap
 import { iconToString } from './src/components/icons';
 export default Adaptable;
 export declare const _AdaptableAgGrid: typeof AdaptableAgGrid;
-export declare const AdaptableNoCodeWizard: typeof import("./src/agGrid/Adaptable").AdaptableNoCodeWizard;
 export declare const _AdaptableLogger: typeof import("./types").AdaptableLogger;
 export declare const AdaptableQL: {
     ScalarFunctions: import("./vendor/aql/index.js").ScalarFunctionName[];
@@ -57,4 +56,4 @@ export declare const AdaptableColumnType: {
      */
     PivotAggregationTotal: import("./src/AdaptableState/Common/AdaptableColumn").AdaptableColumnTypeName;
 };
-export { iconToString as getIconSVG, AdaptableReactPercentageEditor, AdaptableReactNumberEditor, AdaptableReactDateEditor, AdaptablePercentageEditor, AdaptableNumberEditor, AdaptableDateEditor, AdaptableWizardView, AdaptableUpgradeHelper, type UpgradeConfig, };
+export { iconToString as getIconSVG, AdaptableReactPercentageEditor, AdaptableReactNumberEditor, AdaptableReactDateEditor, AdaptablePercentageEditor, AdaptableNumberEditor, AdaptableDateEditor, AdaptableUpgradeHelper, type UpgradeConfig, };

package/agGrid.js

@@ -1,4 +1,4 @@
-import Adaptable, { AdaptableNoCodeWizard as ABWizard, AdaptableWizardView, AdaptableLogger as ABLogger, } from './src/agGrid';
+import Adaptable, { AdaptableLogger as ABLogger } from './src/agGrid';
 import { AdaptableAgGrid } from './src/agGrid/AdaptableAgGrid';
 import { aggregationCallableNames as aggregatedScalarExpressionFunctionNames, scalarFunctionNames as scalarExpressionFunctionNames, } from "./vendor/aql/index.js";
 import { AdaptableNumberEditor, AdaptableReactNumberEditor, } from './src/agGrid/editors/AdaptableNumberEditor';
@@ -10,7 +10,6 @@ import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT
 import { iconToString } from './src/components/icons';
 export default Adaptable;
 export const _AdaptableAgGrid = AdaptableAgGrid;
-export const AdaptableNoCodeWizard = ABWizard;
 export const _AdaptableLogger = ABLogger;
 export const AdaptableQL = {
     ScalarFunctions: scalarExpressionFunctionNames,
@@ -29,4 +28,4 @@ export const AdaptableColumnType = {
     PivotColumnTotal: PIVOT_COLUMN_TOTAL_COLUMN_TYPE,
     PivotAggregationTotal: PIVOT_AGGREGATION_TOTAL_COLUMN_TYPE,
 };
-export { iconToString as getIconSVG, AdaptableReactPercentageEditor, AdaptableReactNumberEditor, AdaptableReactDateEditor, AdaptablePercentageEditor, AdaptableNumberEditor, AdaptableDateEditor, AdaptableWizardView, AdaptableUpgradeHelper, };
+export { iconToString as getIconSVG, AdaptableReactPercentageEditor, AdaptableReactNumberEditor, AdaptableReactDateEditor, AdaptablePercentageEditor, AdaptableNumberEditor, AdaptableDateEditor, AdaptableUpgradeHelper, };

package/aql.d.ts

@@ -0,0 +1,132 @@
+import type { AdaptableColumnDataType } from './src/AdaptableState/Common/AdaptableColumn';
+import type { AdaptableStandardExpressionModule } from './src/AdaptableState/Common/Types';
+import { type LegacyExpressionKind } from './src/aql/legacyExpressionKinds';
+/**
+ * What an Expression returns, and whether it is evaluated per row or across rows:
+ * - `boolean` - Standard boolean Expressions: Grid Filter, Column Filter, Format Column,
+ *   Alert and Flashing Cell rules, Named Queries, Reports; also Relative Change
+ *   (`ANY_CHANGE()`) and boolean Observable rules (`CHANGE_COUNT{[price], WITHIN(5m)} >= 2`)
+ * - `scalar` - Standard Expressions returning a value: Calculated Columns, scalar Named
+ *   Queries; also Observable values (`MAX{[price], WITHIN(1d)}`)
+ * - `aggregatedScalar` - Aggregation Expressions in Calculated Columns (`SUM{[price]}`),
+ *   including Cumulative, Quantile and Window Expressions (`LAG{[price], 1, OVER([date])}`)
+ * - `aggregatedBoolean` - Aggregation rules in Alerts (`SUM{[price]} > 100`)
+ *
+ * Which of these a Module accepts, and which Functions it offers, is checked
+ * when `module` is passed to {@link validateExpression}.
+ */
+export type AdaptableQLExpressionKind = LegacyExpressionKind;
+export interface ValidateExpressionOptions {
+    kind: AdaptableQLExpressionKind;
+    /**
+     * Module the Expression belongs to. Applies that Module's rules: Observable
+     * Functions only in Alert, Calculated Column, Format Column and Flashing
+     * Cell; Relative Change Functions only in Alert and Flashing Cell;
+     * Cumulative and Window Functions only in Calculated Columns; aggregated
+     * kinds only in the Modules that evaluate them. When omitted, every
+     * system Function is accepted.
+     */
+    module?: AdaptableStandardExpressionModule;
+    /**
+     * Column Id to AdapTable data type. When provided, references to other
+     * Columns are errors and Column types are checked against Function inputs.
+     */
+    columns?: Record<string, AdaptableColumnDataType | undefined>;
+}
+export interface ExpressionValidationIssue {
+    /** Stable identifier, e.g. `AQL_LEGACY_SPELLING`; absent for generic type errors */
+    code?: string;
+    message: string;
+    severity: 'error' | 'warning' | 'info';
+    /** Character range in the Expression `[start, end)` */
+    range?: [number, number];
+    /** Suggested rewrite, when one exists */
+    quickFix?: {
+        label: string;
+        replacement: string;
+        range?: [number, number];
+    };
+}
+export interface ExpressionValidationResult {
+    isValid: boolean;
+    issues: ExpressionValidationIssue[];
+}
+export interface MigrateExpressionResult {
+    /** Current-syntax Expression, or the input unchanged when it does not parse */
+    expression: string;
+    changed: boolean;
+    /** Set when the input does not parse */
+    error?: string;
+    /** How a rewritten legacy observable rule differs in meaning from the original */
+    notes?: string[];
+}
+export interface ExpressionFunctionDescription {
+    name: string;
+    /** `paren` is `NAME(...)`, `brace` is `NAME{...}` */
+    callForm: 'paren' | 'brace';
+    group: 'scalar' | 'aggregation' | 'observable' | 'clause';
+    returnType?: string;
+    description?: string;
+    signatures: string[];
+    examples: string[];
+    category?: string;
+    /**
+     * Modules whose Expressions offer the Function (a context requirement such
+     * as data-change events, or product policy). Absent when every Module
+     * offers it; empty when only system-internal evaluation (Layout row
+     * summaries, Cell Summaries) does.
+     */
+    modules?: AdaptableStandardExpressionModule[];
+}
+/**
+ * What a Module's Expressions may be (see {@link validateExpression}): the
+ * kinds it evaluates and the Function families it offers.
+ */
+export interface ExpressionModuleCapabilities {
+    module: AdaptableStandardExpressionModule;
+    /** Kinds the Module evaluates, the default (what an Expression without further hints is) first */
+    kinds: AdaptableQLExpressionKind[];
+    /** Whether observable brace calls (`CHANGE_COUNT{[price], WITHIN(5m)}`) are accepted */
+    observableCalls: boolean;
+    /** Whether the data-change Functions (`ANY_CHANGE`, `PERCENT_CHANGE`, `ABSOLUTE_CHANGE`) are available */
+    dataChangeFunctions: boolean;
+}
+/**
+ * Validates an AdapTableQL Expression without a grid. Mirrors
+ * `ExpressionApi.isValidBooleanExpression` / `isValidScalarExpression` /
+ * `isValidAggregatedScalarExpression` / `isValidAggregatedBooleanExpression`,
+ * but reports every issue (with ranges and quick fixes) instead of the first.
+ *
+ * Pre-v24 spellings (`CUMUL(...)`, `TIMEFRAME(...)`, paren aggregations) are
+ * errors; convert them with {@link migrateExpression} first.
+ */
+export declare function validateExpression(expressionInput: string, options: ValidateExpressionOptions): ExpressionValidationResult;
+/**
+ * Converts a pre-v24 AdapTableQL Expression to the current syntax: brace
+ * aggregations (`SUM{[price]}`), named operands (`CUMULATIVE(...)`,
+ * `WITHIN(5m)`), no `CUMUL(...)` / `TIMEFRAME(...)` wrappers. Same logic as
+ * `ExpressionApi.migratePreV24Expression`.
+ *
+ * Pass `kind` for single-argument dual names: `SUM([x])` is an aggregation
+ * in the aggregated kinds and a row-wise scalar elsewhere.
+ *
+ * Legacy observable rules (`ROW_CHANGE(COUNT([price], 3), TIMEFRAME('5m'))`)
+ * are rewritten to observable calls (`CHANGE_COUNT{[price], WITHIN(5m)} >= 3`),
+ * as the State upgrade does for Alerts.
+ */
+export declare function migrateExpression(expression: string, options?: {
+    kind?: AdaptableQLExpressionKind;
+}): MigrateExpressionResult;
+/**
+ * Every system Expression Function, aggregation, observable function and
+ * clause, with its signatures and examples, and the Modules that offer it
+ * when that is not every Module.
+ */
+export declare function getExpressionFunctionCatalogue(): ExpressionFunctionDescription[];
+/**
+ * Which Expression kinds each standard Module evaluates and which Function
+ * families it offers — the rules {@link validateExpression} applies when
+ * `module` is passed, as data. Derived from the same constants, so the two
+ * cannot disagree.
+ */
+export declare function getExpressionModuleCapabilities(): ExpressionModuleCapabilities[];

package/aql.js

@@ -0,0 +1,260 @@
+import { CLAUSE_DOCS, SYSTEM_AGGREGATION_CATALOGUE, compileValueExpression, isAST_Function, mapDataTypeToStaticType, migrateExpression as migrateAqlExpression, normalizeAst, parse, validateAqlExpression, validateExpressionTypes, } from "./vendor/aql/index.js";
+import { AGGREGATED_BOOLEAN_MODULES, DATA_CHANGE_MODULES, moduleAllowsObservableCalls, } from './src/aql/expressionFunctionAvailability';
+import { getMissingColumnIssues } from './src/aql/getMissingColumnIssues';
+import { mapLegacyKindToValidationRequest, toMigrateOptions, } from './src/aql/legacyExpressionKinds';
+import { systemAggregatedExpressionFunctions, systemAggregationClauseFunctions, systemObservableExpressionFunctions, systemScalarExpressionFunctions, } from './src/aql/systemExpressionFunctions';
+const scalarFunctions = {
+    ...systemObservableExpressionFunctions,
+    ...systemScalarExpressionFunctions,
+};
+const isAggregatedKind = (kind) => kind === 'aggregatedScalar' || kind === 'aggregatedBoolean';
+const AGGREGATED_KIND_MODULES = {
+    aggregatedScalar: ['CalculatedColumn'],
+    aggregatedBoolean: AGGREGATED_BOOLEAN_MODULES,
+};
+const scalarPool = systemScalarExpressionFunctions;
+const aggregationPool = {
+    ...systemAggregatedExpressionFunctions,
+    ...systemAggregationClauseFunctions,
+};
+function getModuleAvailabilityIssues(ast, module, aggregated) {
+    const issues = [];
+    const reported = new Set();
+    const visit = (node) => {
+        if (node == null || typeof node !== 'object') {
+            return;
+        }
+        if (Array.isArray(node)) {
+            node.forEach(visit);
+            return;
+        }
+        if (!isAST_Function(node)) {
+            Object.values(node).forEach(visit);
+            return;
+        }
+        const fn = node;
+        const kind = fn.kind ?? fn.metaInfo;
+        if (kind === 'OBSERVABLE_CALL') {
+            return;
+        }
+        const scalar = kind === 'FUNCTION' ? scalarPool[fn.type] : undefined;
+        const modules = (scalar ?? (aggregated ? aggregationPool[fn.type] : undefined))?.isAvailable;
+        if (Array.isArray(modules) && !modules.includes(module)) {
+            if (!reported.has(fn.type)) {
+                reported.add(fn.type);
+                issues.push({
+                    code: 'AQL_NOT_AVAILABLE_IN_MODULE',
+                    message: `${fn.type} is not available in ${module} Expressions (only in ${modules.join(', ')})`,
+                    severity: scalar ? 'error' : 'warning',
+                    range: fn.range,
+                });
+            }
+            return;
+        }
+        fn.args.forEach(visit);
+    };
+    visit(ast);
+    return issues;
+}
+const error = (message, code) => ({
+    code,
+    message,
+    severity: 'error',
+});
+const toResult = (issues) => {
+    const byKey = new Map();
+    for (const issue of issues) {
+        const key = `${issue.message}::${issue.range?.join(',') ?? ''}`;
+        if (!byKey.get(key)?.code) {
+            byKey.set(key, issue);
+        }
+    }
+    const unique = [...byKey.values()];
+    return {
+        isValid: !unique.some((issue) => issue.severity === 'error'),
+        issues: unique,
+    };
+};
+export function validateExpression(expressionInput, options) {
+    const expression = (expressionInput ?? '').trim();
+    if (expression === '') {
+        return toResult([error(`empty ${options.kind} expression`, 'AQL_EMPTY')]);
+    }
+    let ast;
+    try {
+        ast = parse(expression).ast;
+    }
+    catch (e) {
+        return toResult([error(e instanceof Error ? e.message : String(e), 'AQL_PARSE_ERROR')]);
+    }
+    const columns = options.columns;
+    const getColumnType = columns
+        ? (columnId) => mapDataTypeToStaticType(columns[columnId])
+        : undefined;
+    const issues = [];
+    if (!isAggregatedKind(options.kind)) {
+        const rootFn = ast[ast.length - 1];
+        if (rootFn?.type === undefined || scalarFunctions[rootFn.type] === undefined) {
+            return toResult([
+                error(`provided function ${rootFn?.type} cannot be handled`, 'AQL_UNKNOWN_FUNCTION'),
+            ]);
+        }
+        const typeCheck = validateExpressionTypes(ast, scalarFunctions, {
+            getBraceCallSpec: SYSTEM_AGGREGATION_CATALOGUE.getBraceCallSpec,
+            getColumnType,
+        });
+        issues.push(...typeCheck.issues);
+    }
+    const { module } = options;
+    let kindInModule = true;
+    if (module && isAggregatedKind(options.kind)) {
+        const modules = AGGREGATED_KIND_MODULES[options.kind];
+        kindInModule = modules.includes(module);
+        if (!kindInModule) {
+            issues.push(error(`${module} does not evaluate ${options.kind} Expressions (only ${modules.join(', ')} does)`, 'AQL_KIND_NOT_IN_MODULE'));
+        }
+    }
+    const structure = validateAqlExpression(ast, {
+        request: {
+            ...mapLegacyKindToValidationRequest(options.kind),
+            requiresAggCalls: false,
+            allowsObservableCalls: module ? moduleAllowsObservableCalls(module) : true,
+        },
+        scalarFunctions,
+        catalogue: SYSTEM_AGGREGATION_CATALOGUE,
+        getColumnType,
+    });
+    issues.push(...structure.issues);
+    if (module && kindInModule) {
+        issues.push(...getModuleAvailabilityIssues(structure.normalizedAst, module, isAggregatedKind(options.kind)));
+    }
+    if (columns) {
+        issues.push(...getMissingColumnIssues(ast, (columnId) => columnId in columns).map((issue) => ({
+            ...issue,
+            code: 'AQL_UNKNOWN_COLUMN',
+        })));
+    }
+    if (isAggregatedKind(options.kind) && !issues.some((issue) => issue.severity === 'error')) {
+        const mismatch = error(`provided ${options.kind} expression does not evaluate to a supported aggregation`, 'AQL_AGG_REQUIRED');
+        try {
+            const compiled = compileValueExpression(normalizeAst(ast), {
+                registry: SYSTEM_AGGREGATION_CATALOGUE,
+                getColumnType,
+                scalarFunctions: systemScalarExpressionFunctions,
+            });
+            const isBoolean = compiled.outputType === 'boolean';
+            if (compiled.aggregations.length === 0 ||
+                (options.kind === 'aggregatedBoolean' && !isBoolean) ||
+                (options.kind === 'aggregatedScalar' && isBoolean)) {
+                issues.push(mismatch);
+            }
+        }
+        catch (e) {
+            issues.push(error(e instanceof Error ? e.message : String(e)));
+        }
+    }
+    return toResult(issues);
+}
+export function migrateExpression(expression, options) {
+    const result = migrateAqlExpression((expression ?? '').trim(), {
+        ...toMigrateOptions(options?.kind),
+        rewriteLegacyObservables: true,
+    });
+    return {
+        expression: result.expression,
+        changed: result.changed,
+        ...(result.error !== undefined ? { error: result.error } : {}),
+        ...(result.notes?.length ? { notes: result.notes.map((note) => note.message) } : {}),
+    };
+}
+const MODULE_STANDARD_KINDS = {
+    Alert: ['boolean'],
+    CalculatedColumn: ['scalar', 'boolean'],
+    ColumnFilter: ['boolean'],
+    Export: ['boolean'],
+    FlashingCell: ['boolean'],
+    FormatColumn: ['boolean'],
+    GridFilter: ['boolean'],
+    NamedQuery: ['boolean', 'scalar'],
+    PlusMinus: ['boolean'],
+    StyledColumn: ['boolean'],
+};
+const STANDARD_MODULES = Object.keys(MODULE_STANDARD_KINDS);
+function modulesOf(entry) {
+    const available = entry?.isAvailable;
+    if (!Array.isArray(available)) {
+        return {};
+    }
+    const standard = STANDARD_MODULES;
+    return {
+        modules: available.filter((module) => standard.includes(module)),
+    };
+}
+export function getExpressionFunctionCatalogue() {
+    const scalar = Object.entries(systemScalarExpressionFunctions).map(([name, fn]) => ({
+        name,
+        callForm: 'paren',
+        group: 'scalar',
+        returnType: fn.returnType,
+        description: fn.description,
+        signatures: fn.signatures ?? [],
+        examples: fn.examples ?? [],
+        category: fn.category,
+        ...modulesOf(fn),
+    }));
+    const aggregations = SYSTEM_AGGREGATION_CATALOGUE.callables()
+        .filter((callable) => callable.system)
+        .map((callable) => ({
+        name: callable.name,
+        callForm: callable.callForm,
+        group: 'aggregation',
+        description: callable.docs.description,
+        signatures: callable.docs.signatures ?? [],
+        examples: callable.docs.examples ?? [],
+        category: callable.docs.category,
+        ...modulesOf(aggregationPool[callable.name]),
+    }));
+    const observables = Object.entries(systemObservableExpressionFunctions).map(([name, fn]) => ({
+        name,
+        callForm: 'brace',
+        group: 'observable',
+        returnType: fn.returnType,
+        description: fn.description,
+        signatures: fn.signatures ?? [],
+        examples: fn.examples ?? [],
+        category: fn.category,
+        ...modulesOf(fn),
+    }));
+    const observablePool = systemObservableExpressionFunctions;
+    const clauses = Object.entries(CLAUSE_DOCS).map(([name, docs]) => ({
+        name,
+        callForm: 'paren',
+        group: 'clause',
+        description: docs.description,
+        signatures: docs.signatures,
+        examples: docs.examples,
+        category: docs.category,
+        ...modulesOf(aggregationPool[name] ?? observablePool[name]),
+    }));
+    return [...scalar, ...aggregations, ...observables, ...clauses];
+}
+export function getExpressionModuleCapabilities() {
+    const aggregatedBoolean = AGGREGATED_KIND_MODULES.aggregatedBoolean;
+    const aggregatedScalar = AGGREGATED_KIND_MODULES.aggregatedScalar;
+    const dataChange = DATA_CHANGE_MODULES;
+    return STANDARD_MODULES.map((module) => {
+        const kinds = [...MODULE_STANDARD_KINDS[module]];
+        if (aggregatedScalar.includes(module)) {
+            kinds.push('aggregatedScalar');
+        }
+        if (aggregatedBoolean.includes(module)) {
+            kinds.push('aggregatedBoolean');
+        }
+        return {
+            module,
+            kinds,
+            observableCalls: moduleAllowsObservableCalls(module),
+            dataChangeFunctions: dataChange.includes(module),
+        };
+    });
+}