@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.1

package/src/aql/types.d.ts

@@ -0,0 +1,572 @@
+import type { AST_Expression, ExpressionContext as AqlExpressionContext, ExpressionFunction as AqlExpressionFunction, ExpressionFunctionInputType, ExpressionReturnType, HostExpressionContext, OperatorRhsSlot } from "../../vendor/aql/index.js";
+import type { CellDataChangedInfo } from '../AdaptableState/Common/CellDataChangedInfo';
+import type { BaseContext } from '../AdaptableState/Common/BaseContext';
+import type { AdaptableIcon } from '../AdaptableState/Common/AdaptableIcon';
+import type { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
+import type { ColumnScope } from '../AdaptableState/Common/ColumnScope';
+import type { AdaptableAggregatedExpressionModule, AdaptableModule, AdaptableStandardExpressionModule, AggregatedExpressionHostModule } from '../AdaptableState/Common/Types';
+import type { IRowNode } from 'ag-grid-enterprise';
+/**
+ * The javascript function which is invoked by an AdaptableQL Function.
+ * Custom handlers are authored against the public
+ * {@link AdaptableExpressionContext}.
+ */
+export type AdaptableExpressionFunctionHandler = (
+/**
+ * Args passed into function to enable evaluation
+ */
+args: any[], 
+/**
+ * Context Object - including the public aql accessors and AdaptableAPI
+ */
+context: AdaptableExpressionContext) => any;
+/**
+ * Defines how an AdaptableQL Function is described in Expression Editor
+ */
+export type ExpressionFunctionDocBlock = {
+    type: 'code';
+    content: string;
+} | {
+    type: 'paragraph';
+    content: string;
+};
+/**
+ * The context an Adaptable custom expression function handler is documented
+ * against: aql's host-agnostic accessors plus the Adaptable extras users
+ * legitimately need (`adaptableApi`, `adaptableContext`, …).
+ *
+ * Evaluator plumbing (`functions`) and host internals (`filterFn`,
+ * `namedQueryCallStack`, pivot / override state) are deliberately absent —
+ * see `AdaptableInternalExpressionContext`. `argNodes` is the one piece of
+ * evaluator provenance kept public: it is the documented mechanism for a
+ * custom/extended handler to recover the column id behind an argument (see
+ * `getExpressionArgColumnId`), used by the system-function-override recipe.
+ */
+export interface AdaptableExpressionContext extends BaseContext, AqlExpressionContext {
+    /**
+     * Column a scoped rule applies to — the subject of `$SCOPE`. Present only
+     * where the calling module supplies a scope (ColumnFilter, Badge, …).
+     */
+    columnScope?: string;
+    /**
+     * Raw AST nodes of the current function's arguments, index-aligned with
+     * the evaluated `args` array. Best-effort: `undefined` for computed args
+     * (e.g. `LOWER([make])`). Use with `getExpressionArgColumnId` to recover
+     * subject provenance — e.g. to fetch a column's raw value from within a
+     * custom/extended handler.
+     */
+    argNodes?: AST_Expression[];
+}
+/**
+ * Context used by the evaluator and by Adaptable's system function packs.
+ *
+ * Extends the aql host-bound context, so the ported functions read values
+ * through {@link import('@adaptabletools/aql').AqlHost} rather than through
+ * `adaptableApi`. The legacy fat context maps onto it as follows:
+ *
+ * | Legacy `ExpressionContext` field | Replacement |
+ * |---------------------------------|-------------|
+ * | `node`                          | `rowRef` (+ `getRowData` / `getRawColumnValue`) |
+ * | `pivotResultColumn`             | `columnValueAliases` |
+ * | `getRowNodes`                   | `host.rows.getRowRefs` |
+ * | `evaluateQueryVariable`         | `host.variables.getQueryVariable` |
+ * | `whereClauseFunctions` / `filterFn` / `cellValueOverride` / `namedQueryCallStack` | same names, on the aql context |
+ * | `adaptableApi` (and BaseContext) | `ext` (flattened onto the context) |
+ */
+export interface AdaptableInternalExpressionContext extends AdaptableExpressionContext, HostExpressionContext {
+    /**
+     * @deprecated Use `cellDataChange` (the aql-shaped change). No longer
+     * populated on the evaluation context.
+     */
+    dataChangedEvent?: CellDataChangedInfo;
+}
+/**
+ * The kinds of expression function.
+ *
+ * Note: boolean predicates are `scalar` functions with
+ * `returnType: 'boolean'`; the boolean aggregation operators (`WHERE`,
+ * threshold comparators) are part of `aggregated`. `observable` are the
+ * brace-only history readers (`CHANGE_COUNT{}`, `PREVIOUS{}`, `ROW_AGE{}`, …)
+ * and their clause keywords (`ANY_COL`, `WITHIN`, `LAST_N`, `ALL_ROWS`, `TRIGGER`).
+ */
+export type ExpressionFunctionType = 'scalar' | 'aggregated' | 'observable';
+/**
+ * Context for `AdaptableExpressionFunctionEnhancement.isAvailable` and (as a
+ * base) for the global `expressionOptions.isExpressionFunctionAvailable`.
+ * Identifies the function being queried and the module requesting it.
+ */
+export interface ExpressionFunctionAvailabilityContext extends BaseContext {
+    /**
+     * The module requesting the function (e.g. ColumnFilter, GridFilter,
+     * CalculatedColumn, Alert). May be `undefined` in rare cases —
+     * callbacks must tolerate it.
+     */
+    module: AdaptableModule | undefined;
+    /**
+     * The function's registered name / AQL keyword (e.g. `GT`, `CONTAINS`,
+     * `SUM`, a custom function name).
+     */
+    functionName: string;
+    /**
+     * The kind of expression function (scalar, observable or aggregated).
+     */
+    functionType: ExpressionFunctionType;
+    /**
+     * The function definition itself (argument model, docs and Adaptable
+     * enhancement metadata). Scalar / observable entries also carry the
+     * handler; aggregation entries are docs-only.
+     */
+    expressionFunction: AdaptableExpressionFunctionMetadata;
+    /**
+     * `false` for built-in system functions, `true` for user-registered
+     * custom functions.
+     */
+    isCustom: boolean;
+    /**
+     * The Column the function is being offered for. Set **only** when resolving
+     * the operator list for a specific Column Filter (so `isExpressionFunctionAvailable`
+     * can allow/deny operators per Column); `undefined` for module-level
+     * resolution. Callbacks must tolerate it being `undefined`.
+     */
+    column?: AdaptableColumn;
+    /**
+     * The `ColumnScope` for {@link column} (a single-Column scope). Provided
+     * alongside `column` for Column Filter operator resolution; `undefined`
+     * otherwise.
+     */
+    columnScope?: ColumnScope;
+}
+/**
+ * Application-specific properties Adaptable layers **on top of** an aql
+ * expression-function definition. aql's own `ExpressionFunction` is lean —
+ * evaluation behaviour, the argument/type model and documentation strings —
+ * while everything a grid application needs to *present* the function lives
+ * here.
+ *
+ * System functions get these via the enhancement map in
+ * `src/aql/systemExpressionFunctionEnhancements.ts`; custom functions supply
+ * them inline on the flat {@link AdaptableCustomExpressionFunction} object.
+ */
+export interface AdaptableExpressionFunctionEnhancement {
+    /**
+     * Human-friendly display name for the function / operator, shown in
+     * operator pickers such as the ColumnFilter operator dropdown. When
+     * omitted it falls back to the function's registered name (its id).
+     */
+    label?: string;
+    /**
+     * Optional per-subject-type display labels (e.g. BETWEEN → "Between" for
+     * numbers, "Range" for dates). Falls back to {@link label} when absent.
+     */
+    labelsBySubjectType?: Partial<Record<ExpressionFunctionInputType, string>>;
+    /**
+     * Icon to show for the function (e.g. in ColumnFilter operator dropdown
+     * and QueryBuilder).
+     */
+    icon?: AdaptableIcon | {
+        text: string;
+    };
+    /**
+     * Optional per-subject-type icons. Falls back to {@link icon} when absent.
+     */
+    iconsBySubjectType?: Partial<Record<ExpressionFunctionInputType, AdaptableIcon | {
+        text: string;
+    }>>;
+    /**
+     * Quick Filter bar keystroke(s) that select this operator (e.g. `['=']`,
+     * `['#', '[']`). Only meaningful for boolean operators used in the
+     * ColumnFilter. Can be overridden per column via
+     * `columnFilterOptions.quickFilterWildcards`.
+     */
+    shortcuts?: string[];
+    /**
+     * Removes entry from Expression Editor's Functions dropdown (used for
+     * operators written as infix symbols such as `+`, `=`, `<`).
+     */
+    isHiddenFromMenu?: boolean;
+    /**
+     * Optional, sparse, positional configuration for the NON-SUBJECT
+     * operands (the RHS for operators; all args for value sources). Index 0
+     * is the first non-subject operand. Anything omitted uses the
+     * QueryBuilder conventions derived from the aql `operands` matrix (all
+     * operand sources allowed; column-aware value editor for text/number,
+     * free editor for date/boolean).
+     */
+    rhs?: OperatorRhsSlot[];
+    /**
+     * Data Types of Inputs required by Expression.
+     *
+     * @deprecated for QueryBuilder purposes — use the aql `operands` matrix
+     * instead. Retained only for the Row Summary wizard's aggregation
+     * type-applicability.
+     */
+    inputs?: ExpressionFunctionInputType[] | ExpressionFunctionInputType[][];
+    /**
+     * Where the function is available. `undefined` (default) means available
+     * in **all** relevant modules for that function kind.
+     *
+     * Prefer the narrowed forms on {@link AdaptableCustomExpressionFunction}
+     * (`AdaptableStandardExpressionModule`) and
+     * {@link AggregatedExpressionFunction}
+     * (`AdaptableAggregatedExpressionModule`). This wider union exists so the
+     * system pool overlay can attach either kind (including Layout / Cell
+     * Summary hosts for built-in aggregations).
+     *
+     * The final decision can still be overridden centrally via
+     * `expressionOptions.isExpressionFunctionAvailable`.
+     *
+     * System functions do not set this inline: their availability comes
+     * from the aql `requires` declaration and the enhancement map's
+     * availability policy (`src/aql/systemExpressionFunctionEnhancements.ts`).
+     */
+    isAvailable?: ReadonlyArray<AdaptableStandardExpressionModule | AggregatedExpressionHostModule> | ((context: ExpressionFunctionAvailabilityContext) => boolean);
+}
+/**
+ * The definition shape flowing through `QueryLanguageService` pools and all
+ * Adaptable UI consumers: aql's lean evaluation definition **plus** the
+ * Adaptable enhancement.
+ *
+ * The handler context is `AdaptableInternalExpressionContext` — the host
+ * evaluation context Adaptable actually passes. Both system pack handlers
+ * (written against aql's `HostExpressionContext`) and custom handlers
+ * (written against the public `AdaptableExpressionContext`) are assignable
+ * here; see the bivariance note on aql's `ExpressionFunction.handler`.
+ */
+export type AdaptableExpressionFunction = AqlExpressionFunction<AdaptableInternalExpressionContext> & AdaptableExpressionFunctionEnhancement;
+/**
+ * Name-keyed pool of enriched definitions — the value type of the
+ * `QueryLanguageService` module pools. The `T | string` key mirrors the
+ * legacy map shape: pools always admit custom functions under arbitrary
+ * names next to the known system names.
+ */
+export type AdaptableExpressionFunctionMap<T extends string = string> = Record<T | string, AdaptableExpressionFunction>;
+/**
+ * What UI surfaces (Expression Editor menus / chips / hover docs,
+ * QueryBuilder, Row Summary wizard) read from a pool entry: the argument /
+ * type model, documentation and Adaptable presentation — never the
+ * `handler`. Every {@link AdaptableExpressionFunction} is one; aggregation
+ * pool entries are *only* this (see {@link AdaptableAggregationFunctionDef}).
+ */
+export type AdaptableExpressionFunctionMetadata = Omit<AqlExpressionFunction<AdaptableInternalExpressionContext>, 'handler' | 'hasEagerEvaluation'> & AdaptableExpressionFunctionEnhancement;
+/**
+ * Name-keyed pool as consumed by presentation surfaces. Scalar pools
+ * (handler-bearing) are assignable to it; the aggregation pool *is* one.
+ */
+export type AdaptableExpressionFunctionMetadataMap<T extends string = string> = Record<T | string, AdaptableExpressionFunctionMetadata>;
+/**
+ * An aggregation pool entry: documentation, schema and presentation only.
+ * There is no `handler` — aggregations are not evaluated through the scalar
+ * evaluator. Their semantics live on the `AggregationOperator` the aql
+ * aggregation catalogue resolves for the name (system operators, sugar, or
+ * a custom operator adapted from {@link AggregatedExpressionFunction}).
+ */
+export type AdaptableAggregationFunctionDef = AdaptableExpressionFunctionMetadata;
+/** Name-keyed aggregation pool (system callables + clause keywords + customs). */
+export type AdaptableAggregationFunctionMap<T extends string = string> = Record<T | string, AdaptableAggregationFunctionDef>;
+/**
+ * A 3rd-party custom expression function: one **flat** object combining the
+ * aql evaluation properties (`handler`, `returnType`, `operands`, docs, …)
+ * with the Adaptable-specific enhancement properties (`icon`, `label`,
+ * `isAvailable`, `rhs`, …).
+ *
+ * The handler is typed against the public {@link AdaptableExpressionContext}
+ * so evaluator internals are not part of the authoring contract.
+ *
+ * Registered via `expressionOptions.customStandardFunctions` (boolean
+ * predicates are custom standard functions with `returnType: 'boolean'`).
+ *
+ * `returnType` is mandatory so AdapTable can distinguish predicates from
+ * value-producing functions — prefer {@link ExpressionReturnType} /
+ * `EXPRESSION_RETURN_TYPES`. `string & {}` keeps literal autocomplete while
+ * remaining assignable when TypeScript widens `'boolean'` to `string` (common
+ * for object literals in a `Record | callback` union).
+ *
+ * Boolean predicates with `operands` of arity 1 or 2 appear in Query Builder
+ * / ColumnFilter (optional {@link AdaptableExpressionFunctionEnhancement.label}
+ * for the operator picker). Arity 0 / 3+ or non-boolean stay Expression-Editor-only.
+ *
+ * `isAvailable` is narrowed to {@link AdaptableStandardExpressionModule}
+ * (not Layout / Cell Summary — those are aggregation-only).
+ */
+export type AdaptableCustomExpressionFunction = Omit<AqlExpressionFunction<AdaptableExpressionContext> & AdaptableExpressionFunctionEnhancement, 'isAvailable' | 'returnType'> & {
+    returnType: ExpressionReturnType | (string & {});
+    isAvailable?: AdaptableStandardExpressionModule[] | ((context: ExpressionFunctionAvailabilityContext) => boolean);
+};
+/**
+ * Partial custom function that inherits every unspecified field from
+ * the system (or previously-registered custom) function named by `extends`.
+ * Used by the expression-function override mechanism.
+ */
+export interface AdaptableCustomExpressionFunctionWithExtends extends Partial<AdaptableCustomExpressionFunction> {
+    /**
+     * Name of the function whose metadata to inherit (e.g. `'IS_BLANK'`).
+     */
+    extends: string;
+}
+/**
+ * A `customStandardFunctions` entry: a full definition, or a partial that
+ * inherits unspecified fields via `extends`.
+ *
+ * `extends?: never` on the full branch is a TypeScript discriminant, not a
+ * runtime field. Without it, `A | Partial<A> & { extends: string }` makes
+ * object literals without `extends` fail with "Property 'extends' is
+ * missing" instead of checking the full definition.
+ */
+export type AdaptableCustomExpressionFunctionEntry = (AdaptableCustomExpressionFunction & {
+    extends?: never;
+}) | AdaptableCustomExpressionFunctionWithExtends;
+/**
+ * Static result type a custom aggregation may declare.
+ * `'input'` = same type as the aggregated column.
+ */
+export type AggregatedExpressionReturnType = 'number' | 'text' | 'date' | 'boolean' | 'input';
+/**
+ * Defines an AdapTableQL function that aggregates data
+ */
+export interface AggregatedExpressionFunction {
+    /**
+     * What the aggregation evaluates to (outcome), shown in editor
+     * documentation. Often starts with "Returns …".
+     */
+    description?: string;
+    /**
+     * Example Signatures for the Aggregated Expression Function
+     */
+    signatures?: string[];
+    /**
+     * Examples to use the Aggregated Expression Function
+     */
+    examples?: string[];
+    /**
+     * Freeform Functions-menu section for Alert Aggregated / Calculated Column
+     * Aggregated editors. Omit (or use `'Aggregation'`) to list under Aggregation;
+     * any other string becomes its own section label.
+     */
+    category?: string;
+    /**
+     * Mandatory Initial Value for the aggregation.
+     *
+     * May be a plain value or a factory function returning a fresh value.
+     * Use a factory when the reducer mutates its accumulator (objects, arrays,
+     * Maps, Sets) — plain object values are deep-cloned per aggregation run
+     * (and per group) for backward compatibility, which is slower.
+     */
+    initialValue: any;
+    /**
+     * Mandatory Reducer function which is called for each value(row) in the Column Data
+     */
+    reducer: (context: AggregatedExpressionReducerContext) => any;
+    /**
+     * Called AFTER the reducer() has processed all values / rows
+     * Can be used to change result of reducer based on the values array (e.g. average = aggregated value / count)
+     */
+    processAggregatedValue?: (context: AggregatedExpressionProcessAggValueContext) => any;
+    /**
+     * Called for each row AFTER the reducer() and processAggregatedValue() functions
+     * Can be used when each row has a different aggregated value (e.g. percentage = row value / aggregated value).
+     * Returns return value for each individual row (a boolean suits a boolean Calculated Column, e.g. "is in the top K")
+     */
+    prepareRowValue?: (context: AggregatedExpressionPrepareRowValueContext) => number | string | boolean | Date | undefined;
+    /**
+     * Optional filter which is applied to each row before the reducer is called. If the filter returns false, the row is NOT included in the aggregation.
+     */
+    filterRow?: (context: AggregatedExpressionFilterRowContext) => boolean;
+    /**
+     * Accept a `CUMULATIVE([orderColumn])` clause, e.g.
+     * `MY_AGG{[notional], CUMULATIVE([tradeDate])}`.
+     *
+     * - `true` — generic running variant: rows are visited in `CUMULATIVE`
+     *   order (per `GROUP_BY` partition when grouped), `reducer` accumulates,
+     *   and the value recorded for each row is `processAggregatedValue` (or
+     *   the accumulator when absent) evaluated on the prefix so far.
+     * - object — override the per-row read with `currentValue` when
+     *   `processAggregatedValue` is too expensive to run per row or the
+     *   running value is not a function of the accumulator alone.
+     *
+     * Declaring the capability also makes the clause known to validation, the
+     * Expression Editor clause chips / Cumulative editor and the Query Builder.
+     */
+    cumulative?: boolean | {
+        currentValue: (context: AggregatedExpressionCumulativeValueContext) => any;
+    };
+    /**
+     * Accept a `WEIGHT([column])` clause, e.g.
+     * `MY_VWAP{[price], WEIGHT([quantity])}`. The resolved weight of the
+     * current row is delivered as `weightValue` on the `reducer`,
+     * `prepareRowValue` and `filterRow` contexts (and on the cumulative
+     * `currentValue` context).
+     */
+    weight?: boolean;
+    /**
+     * Static result type of the aggregation. Drives the Calculated Column data
+     * type, the outer expression type check and editor documentation.
+     * `'input'` = same type as the aggregated column (MIN / MAX style). When
+     * omitted the result type is unknown (Calculated Columns default to number).
+     */
+    returnType?: AggregatedExpressionReturnType;
+    /**
+     * Optional argument types.
+     */
+    inputTypes?: ExpressionFunctionInputType[];
+    /**
+     * Where the function is available — same semantics as standard
+     * `isAvailable`, but restricted to {@link AdaptableAggregatedExpressionModule}
+     * (Alert Aggregated and Calculated Column Aggregated).
+     * `undefined` means both aggregated expression modules.
+     */
+    isAvailable?: AdaptableAggregatedExpressionModule[] | ((context: ExpressionFunctionAvailabilityContext) => boolean);
+}
+/**
+ * Context used by the reducer property in Aggregated Expressions
+ */
+export interface AggregatedExpressionReducerContext extends BaseContext {
+    /**
+     * Value returned by the previous call to the reducer function, or the initialValue if this is the first call. You return the new accumulator value from this function.
+     */
+    accumulator: any;
+    /**
+     * Current value being processed in the Column Data
+     */
+    currentValue: any;
+    /**
+     * Index of the current value in the Column Data
+     */
+    index: number;
+    /**
+     * Current row node
+     */
+    rowNode: IRowNode;
+    /**
+     * Arguments passed to the function
+     */
+    args: any[];
+    /**
+     * Column Id of the column being aggregated
+     */
+    aggColumnId: string;
+    /**
+     * Column Id(s) of the column(s) being grouped by
+     */
+    groupByColumnIds?: string[];
+    /**
+     * Helper function to get the value of a column
+     * @param colId column id
+     */
+    getValueForColId: (colId: string) => any;
+    /**
+     * Resolved `WEIGHT([column])` value for the current row.
+     * Only present when the function declares `weight: true` and the call
+     * supplies a WEIGHT clause.
+     */
+    weightValue?: any;
+}
+/**
+ * Context used by processAggregatedValue property in Aggregated Expressions
+ */
+export interface AggregatedExpressionProcessAggValueContext extends BaseContext {
+    /**
+     * Result of the reducer
+     */
+    aggregatedValue: any;
+    /**
+     * Array of row nodes; if aggregation is grouped, this will be the array of row nodes for the group
+     */
+    rowNodes: IRowNode[];
+    /**
+     * Arguments passed to the function
+     */
+    args: any[];
+    /**
+     * Column Id of the column being aggregated
+     */
+    aggColumnId: string;
+    /**
+     * Column Id(s) of the column(s) being grouped by
+     */
+    groupByColumnIds?: string[];
+}
+/**
+ * Context used by `cumulative.currentValue`: the running aggregate after the
+ * reducer has visited the rows up to (and including) the current one.
+ * `aggregatedValue` is the accumulator, `rowNodes` the visited prefix.
+ */
+export interface AggregatedExpressionCumulativeValueContext extends AggregatedExpressionProcessAggValueContext {
+    /**
+     * Row node whose running value is being read
+     */
+    rowNode: IRowNode;
+    /**
+     * Position of the row within its ordered partition
+     */
+    index: number;
+    /**
+     * Resolved `WEIGHT([column])` value for the current row (see `weight`).
+     */
+    weightValue?: any;
+}
+/**
+ * Context used by prepareRowValue property in Aggregated Expressions
+ */
+export interface AggregatedExpressionPrepareRowValueContext extends BaseContext {
+    /**
+     * Current Row Node
+     */
+    rowNode: IRowNode;
+    /**
+     * Result of the reducer (for `CUMULATIVE` calls: the running value
+     * recorded for this row)
+     */
+    aggregatedValue: any;
+    /**
+     * Resolved `WEIGHT([column])` value for the current row (see `weight`).
+     */
+    weightValue?: any;
+    /**
+     * Arguments passed to the function
+     */
+    args: any[];
+    /**
+     * Column Id of the column being aggregated
+     */
+    aggColumnId: string;
+    /**
+     * Column Id(s) of the column(s) being grouped by
+     */
+    groupByColumnIds?: string[];
+    /**
+     * Helper function to get the value of a column
+     * @param colId column id
+     */
+    getValueForColId: (colId: string) => any;
+}
+/**
+ * Context used when applying a filter to Rows before Reducer is called
+ */
+export interface AggregatedExpressionFilterRowContext extends BaseContext {
+    /**
+     * Current row node
+     */
+    rowNode: IRowNode;
+    /**
+     * Arguments passed to the function
+     */
+    args: any[];
+    /**
+     * Column Id of the column being aggregated
+     * Usually the first Col argument, e.g. [colId]
+     */
+    aggColumnId: string;
+    /**
+     * Column Id(s) of the column(s) being grouped by
+     */
+    groupByColumnIds?: string[];
+    /**
+     * Utility function to get the value of a column
+     * @param colId column id
+     */
+    getValueForColId: (colId: string) => any;
+    /**
+     * Resolved `WEIGHT([column])` value for the current row (see `weight`).
+     */
+    weightValue?: any;
+}

package/src/aql/types.js

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

package/src/aql/whereClauseExpressionFunctionPolicy.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Product policy for scalar functions offered in Aggregated / Observable WHERE
+ * editors (menus + CodeMirror pool).
+ *
+ * Kept as an explicit list rather than tagging every aql function definition —
+ * packs stay focused on evaluation and docs; WHERE suitability is a product
+ * decision that can grow without noisy per-function metadata.
+ *
+ * Evaluation still receives the full module scalar pool (hand-typed expressions
+ * are not blocked here). Expand {@link WHERE_CLAUSE_EXCLUDED_FUNCTIONS} /
+ * {@link WHERE_CLAUSE_EXCLUDED_CATEGORIES} as further noise is identified.
+ */
+export declare const WHERE_CLAUSE_EXCLUDED_CATEGORIES: Set<string>;
+export declare const WHERE_CLAUSE_EXCLUDED_FUNCTIONS: Set<string>;
+export declare function isExpressionFunctionAllowedInWhereClause(functionName: string, expressionFunction: {
+    category?: string;
+} | undefined): boolean;
+/** Drop WHERE-excluded entries from a scalar function map (menus / editor pool). */
+export declare function filterWhereClauseExpressionFunctions<T extends Record<string, {
+    category?: string;
+}>>(expressionFunctions: T): T;

package/src/aql/whereClauseExpressionFunctionPolicy.js

@@ -0,0 +1,25 @@
+export const WHERE_CLAUSE_EXCLUDED_CATEGORIES = new Set([
+    'changes',
+]);
+export const WHERE_CLAUSE_EXCLUDED_FUNCTIONS = new Set([
+    'CASE',
+]);
+export function isExpressionFunctionAllowedInWhereClause(functionName, expressionFunction) {
+    if (WHERE_CLAUSE_EXCLUDED_FUNCTIONS.has(functionName)) {
+        return false;
+    }
+    const category = expressionFunction?.category;
+    if (typeof category === 'string' && WHERE_CLAUSE_EXCLUDED_CATEGORIES.has(category)) {
+        return false;
+    }
+    return true;
+}
+export function filterWhereClauseExpressionFunctions(expressionFunctions) {
+    const filtered = { ...expressionFunctions };
+    for (const functionName of Object.keys(filtered)) {
+        if (!isExpressionFunctionAllowedInWhereClause(functionName, filtered[functionName])) {
+            delete filtered[functionName];
+        }
+    }
+    return filtered;
+}

package/src/components/CheckBox/index.d.ts

@@ -1,25 +1,2 @@
-import * as React from 'react';
-import { ReactNode, SyntheticEvent } from 'react';
-import { FlexProps } from '../Flex';
-type TypeProps = {
-    checked?: boolean | null;
-    disabled?: boolean;
-    readOnly?: boolean;
-    as?: any;
-    name?: string;
-    value?: any;
-    variant?: 'default' | 'agGrid';
-    onChange?: (checked: boolean, event: SyntheticEvent) => void;
-    children?: ReactNode;
-    gapDistance?: number | string;
-    childrenPosition?: 'start' | 'end';
-    checkSquareClassName?: string;
-};
-export interface CheckBoxProps extends TypeProps, Omit<React.HTMLProps<HTMLDivElement>, keyof TypeProps | 'ref'> {
-}
-declare const CheckBox: ({ children, checked, onChange, value, name, disabled, readOnly, variant, gapDistance, childrenPosition, checkSquareClassName, tabIndex, as, ...props }: CheckBoxProps) => React.JSX.Element;
-export declare const CheckBoxGroup: (props: FlexProps & {
-    orientation: "horizontal" | "vertical";
-    children?: ReactNode;
-}) => React.JSX.Element;
-export { CheckBox };
+export { CheckBox, CheckBoxGroup } from "../../../vendor/components/CheckBox";
+export type { CheckBoxProps, CheckBoxGroupProps } from "../../../vendor/components/CheckBox";