@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/vendor/aql/store/history/types.d.ts

@@ -0,0 +1,169 @@
+import type { Clock } from './clock';
+/**
+ * Origin of a recorded cell change. The host maps its own trigger union onto
+ * this one (`calculatedColumnChange` → `'calculated'`); incidental
+ * propagation (`aggChange`, `preventEdit`) is never recorded.
+ */
+export type ChangeTrigger = 'edit' | 'tick' | 'undo' | 'calculated';
+/**
+ * Triggers counted when a reader does not spell a `TRIGGER(...)` clause. A
+ * reader with the default trigger set reads the series' pre-aggregated
+ * counters, which count every recorded entry — the host only records
+ * `'calculated'` entries for Calculated Columns, and watching a Calculated
+ * Column as the explicit input opts its recomputations in (catalogue §4.9).
+ */
+export declare const DEFAULT_TRIGGERS: ReadonlySet<ChangeTrigger>;
+export declare const ALL_TRIGGERS: readonly ChangeTrigger[];
+export interface HistoryEntry {
+    readonly t: number;
+    readonly oldValue: unknown;
+    readonly newValue: unknown;
+    readonly trigger: ChangeTrigger;
+}
+export interface HistorySeriesKey {
+    readonly columnId: string;
+    readonly scope: 'row' | 'grid';
+    /** Canonical printed WHERE predicate, `''` when absent. */
+    readonly filterKey: string;
+}
+export declare const seriesKeyToString: (k: HistorySeriesKey) => string;
+export type RowEventKind = 'Add' | 'Delete';
+/** Internal pseudo column id carrying grid row-lifecycle events. */
+export declare const rowEventColumnId: (kind: RowEventKind) => string;
+export declare const rowEventSeriesKey: (kind: RowEventKind, filterKey: string) => HistorySeriesKey;
+/**
+ * Pseudo column id of the `ANY_COL()` union series: every recorded cell
+ * change except Calculated Column recomputations.
+ */
+export declare const ANY_COLUMN_ID = "\0any";
+/**
+ * Pseudo column id of an `ANY_COL([a], [b])` subset union series. Member ids
+ * are de-duplicated and sorted so every spelling of a set shares one series.
+ */
+export declare const anyColumnSubsetId: (columnIds: readonly string[]) => string;
+/** Member column ids of a subset union id, `undefined` for any other id. */
+export declare const anyColumnSubsetMembers: (columnId: string) => string[] | undefined;
+/** Whether a series column id is a union (`ANY_COL()` or a subset). */
+export declare const isAnyColumnId: (columnId: string) => boolean;
+export type HistoryWindow = {
+    kind: 'within';
+    ms: number;
+} | {
+    kind: 'lastN';
+    n: number;
+} | {
+    kind: 'cumulative';
+};
+/**
+ * What one reader needs retained. The series keeps the max over its
+ * readers, capped by the store limits.
+ */
+export interface Retention {
+    windowMs?: number;
+    count?: number;
+}
+export interface RowSeriesView {
+    /**
+     * Retained entries oldest → newest. With `windowMs`, only entries with
+     * `t > now - windowMs`; `undefined` = everything retained.
+     */
+    entries(windowMs?: number, now?: number): ReadonlyArray<HistoryEntry>;
+    /** Allocation-free `entries(windowMs, now).length`. */
+    countInWindow(windowMs: number, now: number): number;
+    /** Allocation-free `entries(windowMs, now)[0]`. */
+    oldestInWindow(windowMs: number, now: number): HistoryEntry | undefined;
+    /** Number of recorded changes since observation start (all triggers). */
+    readonly cumulativeCount: number;
+    /** Recorded changes per trigger since observation start. */
+    countByTrigger(trigger: ChangeTrigger): number;
+    readonly cumulativeHighest: number | undefined;
+    readonly cumulativeLowest: number | undefined;
+    /** `oldValue` of the very first recorded change (value at observation start). */
+    readonly firstOldValue: unknown;
+    readonly lastEntry: HistoryEntry | undefined;
+    /** Sliding max / min over `newValue`s in `windowMs` (or all when `undefined`). */
+    highest(windowMs: number | undefined, now: number): number | undefined;
+    lowest(windowMs: number | undefined, now: number): number | undefined;
+}
+export interface HistoryReader {
+    now(): number;
+    /** Row id for a host row reference (delegates to the store's `getRowId`). */
+    rowIdOf(rowRef: unknown): string | undefined;
+    /** `rowId` is ignored for grid-scope keys. `undefined` when no series / no history for the row. */
+    readSeries(key: HistorySeriesKey, rowId: string | undefined): RowSeriesView | undefined;
+    rowAddedAt(rowId: string): number | undefined;
+    /**
+     * Start of the current observation epoch: store creation, the last `Load`
+     * row change, or the last `reset()`. Full-window reads (`NO_CHANGES`)
+     * count their window from here (or from the row's add, when later).
+     */
+    observationStartAt(): number;
+    rowEvents(kind: RowEventKind, filterKey: string): RowSeriesView | undefined;
+    /** Earliest instant at which a windowed read over this series can change by expiry. */
+    nextExpiryAt(key: HistorySeriesKey, windowMs: number, rowId?: string): number | undefined;
+    /** Row ids whose in-window entries expired in `(sinceT, now]`. */
+    rowsWithExpiry(key: HistorySeriesKey, windowMs: number, sinceT: number): string[];
+    /**
+     * Earliest instant after now at which a full `windowMs` has elapsed since
+     * an epoch — the observation start, and for `'row'` scope every row's add
+     * instant. `undefined` when every such instant has passed.
+     */
+    nextEpochElapseAt(windowMs: number, scope: 'row' | 'grid'): number | undefined;
+    /**
+     * Rows whose epoch + `windowMs` fell in `(sinceT, now]`. `allRows` is true
+     * when the observation-start epoch itself elapsed in that span (every row
+     * present at load is affected); `rowIds` lists rows added since.
+     */
+    rowsWithEpochElapse(windowMs: number, sinceT: number): {
+        allRows: boolean;
+        rowIds: string[];
+    };
+}
+export interface HistoryHandle {
+    readonly key: HistorySeriesKey;
+    release(): void;
+}
+export interface HistoryStoreConfig {
+    clock: Clock;
+    getRowId: (rowRef: unknown) => string | undefined;
+    /** Upper bound for WITHIN retention (host `maxTimeframeSize`). */
+    maxWindowMs: number;
+    /** Ring buffer capacity per row series (host `maxHistoryPerCell`). */
+    maxEntriesPerCell: number;
+    /**
+     * Evaluates a series' WHERE against the row (post-change state). When
+     * absent, series with a non-empty `filterKey` never record.
+     */
+    evaluateFilter?: (filterKey: string, rowRef: unknown) => boolean;
+}
+export interface CellChangeRecord {
+    rowRef: unknown;
+    columnId: string;
+    oldValue: unknown;
+    newValue: unknown;
+    trigger: ChangeTrigger;
+    t?: number;
+}
+export interface RowChangeRecord {
+    trigger: 'Add' | 'Update' | 'Delete' | 'Load';
+    rowRefs: readonly unknown[];
+    t?: number;
+}
+export interface HistoryStats {
+    series: number;
+    rowSeries: number;
+    entries: number;
+    dropped: number;
+}
+export interface HistoryStore extends HistoryReader {
+    acquire(key: HistorySeriesKey, retention: Retention): HistoryHandle;
+    /** Row-event series (`ROWS_ADDED` / `ROWS_REMOVED`); `acquire` declares the window. */
+    acquireRowEvents(kind: RowEventKind, filterKey: string, retention: Retention): HistoryHandle;
+    recordCellChange(change: CellChangeRecord): void;
+    recordRowChange(change: RowChangeRecord): void;
+    /** Drops every recorded entry and row age (new epoch); keeps registrations. */
+    reset(): void;
+    stats(): HistoryStats;
+    destroy(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/vendor/aql/store/history/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/store/history/types.ts"],"names":[],"mappings":"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"}

package/vendor/aql/store/history/types.js

@@ -0,0 +1,39 @@
+/**
+ * Triggers counted when a reader does not spell a `TRIGGER(...)` clause. A
+ * reader with the default trigger set reads the series' pre-aggregated
+ * counters, which count every recorded entry — the host only records
+ * `'calculated'` entries for Calculated Columns, and watching a Calculated
+ * Column as the explicit input opts its recomputations in (catalogue §4.9).
+ */
+export const DEFAULT_TRIGGERS = new Set([
+    'edit',
+    'tick',
+    'undo',
+]);
+export const ALL_TRIGGERS = ['edit', 'tick', 'undo', 'calculated'];
+export const seriesKeyToString = (k) => `${k.scope}\u0000${k.columnId}\u0000${k.filterKey}`;
+/** Internal pseudo column id carrying grid row-lifecycle events. */
+export const rowEventColumnId = (kind) => `\u0000rows:${kind}`;
+export const rowEventSeriesKey = (kind, filterKey) => ({
+    columnId: rowEventColumnId(kind),
+    scope: 'grid',
+    filterKey,
+});
+/**
+ * Pseudo column id of the `ANY_COL()` union series: every recorded cell
+ * change except Calculated Column recomputations.
+ */
+export const ANY_COLUMN_ID = '\u0000any';
+const ANY_COLUMN_SUBSET_PREFIX = '\u0000any:';
+/**
+ * Pseudo column id of an `ANY_COL([a], [b])` subset union series. Member ids
+ * are de-duplicated and sorted so every spelling of a set shares one series.
+ */
+export const anyColumnSubsetId = (columnIds) => `${ANY_COLUMN_SUBSET_PREFIX}${[...new Set(columnIds)].sort().join('\u0000')}`;
+/** Member column ids of a subset union id, `undefined` for any other id. */
+export const anyColumnSubsetMembers = (columnId) => columnId.startsWith(ANY_COLUMN_SUBSET_PREFIX)
+    ? columnId.slice(ANY_COLUMN_SUBSET_PREFIX.length).split('\u0000')
+    : undefined;
+/** Whether a series column id is a union (`ANY_COL()` or a subset). */
+export const isAnyColumnId = (columnId) => columnId === ANY_COLUMN_ID || columnId.startsWith(ANY_COLUMN_SUBSET_PREFIX);
+//# sourceMappingURL=types.js.map

package/vendor/aql/store/history/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/store/history/types.ts"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAA+B,IAAI,GAAG,CAAgB;IACjF,MAAM;IACN,MAAM;IACN,MAAM;CACP,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,YAAY,GAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC;AAgB7F,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAmB,EAAU,EAAE,CAC/D,GAAG,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,QAAQ,SAAS,CAAC,CAAC,SAAS,EAAE,CAAC;AAItD,oEAAoE;AACpE,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAkB,EAAU,EAAE,CAAC,cAAc,IAAI,EAAE,CAAC;AAErF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,IAAkB,EAAE,SAAiB,EAAoB,EAAE,CAAC,CAAC;IAC7F,QAAQ,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAChC,KAAK,EAAE,MAAM;IACb,SAAS;CACV,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,WAAW,CAAC;AAEzC,MAAM,wBAAwB,GAAG,YAAY,CAAC;AAE9C;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,SAA4B,EAAU,EAAE,CACxE,GAAG,wBAAwB,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;AAEhF,4EAA4E;AAC5E,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,QAAgB,EAAwB,EAAE,CAC/E,QAAQ,CAAC,UAAU,CAAC,wBAAwB,CAAC;IAC3C,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC;IACjE,CAAC,CAAC,SAAS,CAAC;AAEhB,uEAAuE;AACvE,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,QAAgB,EAAW,EAAE,CACzD,QAAQ,KAAK,aAAa,IAAI,QAAQ,CAAC,UAAU,CAAC,wBAAwB,CAAC,CAAC"}

package/vendor/aql/store/index.d.ts

@@ -0,0 +1,3 @@
+export { createComputedValueStore, type ComputedValueEngine, type ComputedValueNode, type ComputedValueNodeHandle, type ComputedValueNodeSpec, type ComputedValueStore, type ComputedValueStoreConfig, } from './computedValueStore';
+export * from './history/index';
+//# sourceMappingURL=index.d.ts.map

package/vendor/aql/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,GAC9B,MAAM,sBAAsB,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/vendor/aql/store/index.js

@@ -0,0 +1,3 @@
+export { createComputedValueStore, } from './computedValueStore.js';
+export * from './history/index.js';
+//# sourceMappingURL=index.js.map

package/vendor/aql/store/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,GAOzB,MAAM,sBAAsB,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/vendor/aql/tokenizer/index.d.ts

@@ -0,0 +1,2 @@
+export { getTokens } from './tokenizer';
+//# sourceMappingURL=index.d.ts.map

package/vendor/aql/tokenizer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tokenizer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/vendor/aql/tokenizer/index.js

@@ -0,0 +1,2 @@
+export { getTokens } from './tokenizer.js';
+//# sourceMappingURL=index.js.map

package/vendor/aql/tokenizer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tokenizer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/vendor/aql/tokenizer/tokenizer.d.ts

@@ -0,0 +1,3 @@
+import { Token } from '../types';
+export declare function getTokens(expression: string): Token[];
+//# sourceMappingURL=tokenizer.d.ts.map

package/vendor/aql/tokenizer/tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../../../src/tokenizer/tokenizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAQjC,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE,CA6BrD"}

package/vendor/aql/tokenizer/tokenizer.js

@@ -0,0 +1,29 @@
+import parser from '../parser/parser.js';
+const cache = {};
+const getParser = () => {
+    return parser;
+};
+export function getTokens(expression) {
+    if (cache[expression]) {
+        return cache[expression];
+    }
+    const tokens = [];
+    const lexer = getParser().lexer;
+    lexer.setInput(expression);
+    while (!lexer.done) {
+        const id = lexer.lex();
+        const location = lexer.matched.length;
+        // Lex-only tokens (e.g. INVALID) are absent from terminals_; fall back
+        // so autocomplete / editor consumers still get a stable type string.
+        tokens.push({
+            type: getParser().terminals_[id] ?? 'INVALID',
+            value: lexer.yytext,
+            range: [location - lexer.yytext.length, location],
+        });
+    }
+    // remove eof
+    tokens.pop();
+    cache[expression] = tokens;
+    return tokens;
+}
+//# sourceMappingURL=tokenizer.js.map

package/vendor/aql/tokenizer/tokenizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.js","sourceRoot":"","sources":["../../../src/tokenizer/tokenizer.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC,MAAM,KAAK,GAA4B,EAAE,CAAC;AAE1C,MAAM,SAAS,GAAG,GAAG,EAAE;IACrB,OAAO,MAAa,CAAC;AACvB,CAAC,CAAC;AAEF,MAAM,UAAU,SAAS,CAAC,UAAkB;IAC1C,IAAI,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC;QACtB,OAAO,KAAK,CAAC,UAAU,CAAC,CAAC;IAC3B,CAAC;IAED,MAAM,MAAM,GAAY,EAAE,CAAC;IAC3B,MAAM,KAAK,GAAG,SAAS,EAAE,CAAC,KAAK,CAAC;IAEhC,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAE3B,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,MAAM,EAAE,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QAEtC,uEAAuE;QACvE,qEAAqE;QACrE,MAAM,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,SAAS,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,SAAS;YAC7C,KAAK,EAAE,KAAK,CAAC,MAAM;YACnB,KAAK,EAAE,CAAC,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;SAClD,CAAC,CAAC;IACL,CAAC;IAED,aAAa;IACb,MAAM,CAAC,GAAG,EAAE,CAAC;IAEb,KAAK,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC;IAE3B,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/vendor/aql/types.d.ts

@@ -0,0 +1,329 @@
+/**
+ * An AST Expression (top-level program is a list of expressions).
+ */
+export type AST = AST_Expression[];
+/**
+ * Structural kind of an AST node — the normative discriminator of AST
+ * contract v2:
+ *
+ * - `VALUE_REF` — column ref `[x]`, `$SCOPE`, typed literals (`DURATION`).
+ * - `INFIX` / `UNARY` / `CONDITIONAL` — operators (`SUM`, `NOT`, `IF`/`CASE`).
+ * - `FUNCTION` — paren call `NAME(…)` (row context / scalar).
+ * - `AGG_CALL` — brace call `NAME{…}` in set context. The parser tags every
+ *   brace call `AGG_CALL`; the agg-vs-observable split happens at normalization.
+ * - `OBSERVABLE_CALL` — brace call reading a cell's change history
+ *   (`CHANGE_COUNT{[price], WITHIN(5m)}`, `ROW_AGE{}` …). A value node:
+ *   legal wherever a scalar is legal. Emitted by the normalizer only.
+ * - `CLAUSE` — named operand inside a brace body (`GROUP_BY([x])`,
+ *   `OVER([x])`, `WEIGHT([x])`, `CUMULATIVE([x])`, `WITHIN(5m)`,
+ *   `LAST_N(20)`, `ANY_COL()`, `ALL_ROWS()`, `TRIGGER('edit')`, filter `WHERE p`).
+ */
+export type NodeKind = 'VALUE_REF' | 'INFIX' | 'UNARY' | 'FUNCTION' | 'CONDITIONAL' | 'AGG_CALL' | 'OBSERVABLE_CALL' | 'CLAUSE';
+/**
+ * @deprecated Use {@link NodeKind}. `PredicateType` is the contract-v1 name
+ * of the same discriminator (carried on the deprecated
+ * {@link AST_Function.metaInfo} field); it is retired with the rest of the
+ * legacy surface.
+ */
+export type PredicateType = NodeKind;
+/**
+ * Defines AST of an Expression.
+ *
+ * The recursive `AST_Expression[]` branch captures nested array literals
+ * produced by variadic grammar rules such as `e IN '(' args ')'`
+ * (e.g. `1 IN (1, 2, 3)` → `{ type: 'IN', args: [1, [1, 2, 3]] }`).
+ *
+ * Multi-element parenthesised lists `(a, b, …)` are *not* bare nested arrays:
+ * the grammar `list_expr` lowers them to `{ type: 'TO_ARRAY', … }`.
+ *
+ * `null` is the `NULL` literal (the legacy `NULL()` call parses as an
+ * `AST_Function` until it is normalized).
+ */
+export type AST_Expression = AST_Function | boolean | number | string | null | AST_Expression[];
+/**
+ * Defines AST of an Expression Function
+ */
+export type AST_Function = {
+    type: string;
+    args: AST_Expression[];
+    range?: [number, number];
+    /** Structural kind — the contract-v2 discriminator ({@link NodeKind}). */
+    kind?: NodeKind;
+    /**
+     * @deprecated Contract-v1 duplicate of {@link kind}. The parser and
+     * normalizer keep both fields in sync so consumers that still read
+     * `metaInfo` (contract v1) keep working; removed at contract v3.
+     */
+    metaInfo?: PredicateType;
+};
+/**
+ * Token used by the AQL lexer
+ */
+export type Token = {
+    type: string;
+    value: string;
+    range: [number, number];
+};
+/**
+ * `duration` is a static value type (milliseconds `number` at runtime): the
+ * result of `ROW_AGE{}`, `date - date`, and duration arithmetic.
+ */
+export type ValueDataType = 'number' | 'text' | 'date' | 'boolean' | 'array' | 'duration';
+/**
+ * Public, host-agnostic accessors available to custom ExpressionFunction handlers.
+ *
+ * Keep this surface small and stable — end users author handlers against it
+ * (e.g. via Adaptable `expressionOptions.customStandardFunctions`). Do **not**
+ * put evaluator plumbing or host-private fields here.
+ *
+ * Hosts (Adaptable) may *extend* this type with their own public fields
+ * (e.g. `adaptableApi`) in a separate public interface.
+ */
+export interface ExpressionContext {
+    getRowData: () => unknown;
+    getColumnValue: (columnId: string) => unknown;
+    /**
+     * Underlying cell value before host normalisation, when the host
+     * distinguishes raw vs comparison values. Falls back to
+     * {@link getColumnValue} when the host has no raw-value capability.
+     */
+    getRawColumnValue?: (columnId: string) => unknown;
+    getFieldValue: (field: string) => unknown;
+    /** `undefined` when the column is unknown or its type cannot be inferred. */
+    getColumnDataType: (columnId: string) => ValueDataType | undefined;
+    getFieldDataType: (columnId: string) => ValueDataType | null;
+    /** defaults to false when omitted */
+    isTextComparisonCaseSensitive?: () => boolean;
+}
+/**
+ * @deprecated Use {@link ExpressionContext}. Kept as an alias during the
+ * extraction so older adaptable-ql naming still maps cleanly.
+ */
+export type BaseExpressionContext = ExpressionContext;
+/**
+ * Internal evaluation context. Used by the evaluator and by system / host
+ * function implementations that need registry access or AST provenance.
+ *
+ * Custom ExpressionFunction handlers are typed with {@link ExpressionContext}
+ * only. At runtime they still receive an object that *is* an
+ * `InternalExpressionContext` (structural subtype) — TypeScript simply does
+ * not expose the private fields on the handler signature.
+ */
+export interface InternalExpressionContext extends ExpressionContext {
+    /**
+     * Function registry for this evaluation. Required by the evaluator.
+     * Not part of the public handler API.
+     */
+    functions: ExpressionFunctionMap<InternalExpressionContext>;
+    /**
+     * Raw AST nodes of the current function's arguments, index-aligned with
+     * the evaluated `args` array. Populated by the evaluator on the lazy path.
+     * Not part of the public handler API.
+     */
+    argNodes?: AST_Expression[];
+    /**
+     * Contract-node resolver injected by the value-plan executor: when the
+     * evaluator reaches an `AGG_CALL` / `OBSERVABLE_CALL` node it
+     * asks this hook for the node's value (a slot binding) instead of dispatching
+     * into function handlers. Returning `undefined` means "not a known slot"
+     * and evaluation fails as unevaluatable. Not part of the public handler
+     * API.
+     */
+    resolveContractNode?: (node: AST_Function) => {
+        value: unknown;
+    } | undefined;
+}
+/**
+ * Key-Value map of Expression Names and their implementation.
+ *
+ * `TContext` is the evaluation context the host passes at runtime. Handlers
+ * written against the public {@link ExpressionContext} are always accepted;
+ * handlers that require a richer host context (e.g. Adaptable's) are
+ * accepted too — the host guarantees the evaluation context satisfies every
+ * function it registers (see the bivariance note on
+ * {@link ExpressionFunction.handler}).
+ */
+export type ExpressionFunctionMap<TContext extends ExpressionContext = ExpressionContext> = Record<string, ExpressionFunction<TContext>>;
+/**
+ * Data Types of Inputs used by Expression
+ */
+export type ExpressionFunctionInputType = 'text' | 'number' | 'date' | 'boolean' | 'number[]' | 'date[]' | 'text[]';
+/** Operand type used by the structured QueryBuilder operator model. */
+export type OperandType = ExpressionFunctionInputType | 'any';
+/** One operator/function overload: a bare type or an operand tuple. */
+export type Overload = OperandType | OperandType[];
+/** Per-RHS-slot editor metadata. */
+export interface OperatorRhsSlot {
+    allowedOperands?: ('value' | 'column' | 'field')[];
+    editor?: 'permitted' | 'free' | {
+        enum: string[];
+    };
+    label?: string;
+}
+export type QueryBuilderInputMode = 'column-name' | 'input-value' | 'field';
+export type QueryBuilderValueEditor = 'permitted-values' | 'free' | {
+    enum: string[];
+};
+/**
+ * Recommended `category` values for Expression Functions — especially custom
+ * ones registered via `expressionOptions.customStandardFunctions`.
+ *
+ * Prefer these (TypeScript autocompletes them) so functions land in the matching
+ * Expression Editor menu. Any other string is allowed and becomes its own menu.
+ *
+ * - `logical` / `conditional` → Logical
+ * - `text` / `numeric` / `date` → same-named menus
+ * - `general` / `comparison` → General
+ * - `custom` (or omit `category`) → Custom
+ */
+export declare const EXPRESSION_CATEGORIES: readonly ["logical", "comparison", "text", "numeric", "date", "conditional", "general", "observable", "custom"];
+export type OfficialExpressionCategory = (typeof EXPRESSION_CATEGORIES)[number];
+/**
+ * Official categories (autocomplete) or any custom string for a dedicated menu.
+ * `string & {}` keeps literal autocomplete while allowing arbitrary values.
+ */
+export type ExpressionCategory = OfficialExpressionCategory | (string & {});
+/**
+ * Allowed `returnType` values for Expression Functions.
+ * Prefer these literals (TypeScript autocompletes them).
+ *
+ * - `boolean` — predicate (filters, alerts, WHERE clauses, …)
+ * - `number` / `string` / `date` / `object` — typed scalar results
+ * - `null` — nullish sentinel (e.g. `NULL`)
+ * - `any` — untyped / polymorphic (e.g. `COL`, `IF`)
+ */
+export declare const EXPRESSION_RETURN_TYPES: readonly ["boolean", "number", "string", "date", "object", "null", "any"];
+export type ExpressionReturnType = (typeof EXPRESSION_RETURN_TYPES)[number];
+/**
+ * Evaluation-context capabilities a function's handler cannot work without:
+ *
+ * - `'columnScope'` — the handler throws unless the evaluation supplies a
+ *   column scope (e.g. `$SCOPE`).
+ * - `'dataChange'` — the handler throws unless the evaluation supplies a
+ *   data-changed event (e.g. `ANY_CHANGE`, `PERCENT_CHANGE`).
+ *
+ * This is a *language-level precondition*, declared next to the handler that
+ * enforces it. Hosts map each requirement to the surfaces that provide the
+ * capability (Adaptable maps them to module allow-lists in its availability
+ * overlay); aql itself does not resolve availability.
+ */
+export type AqlContextRequirement = 'columnScope' | 'dataChange';
+/**
+ * Defines an AQL Function used in an Expression.
+ *
+ * Deliberately **lean**: only evaluation behaviour, the argument / type
+ * model, and host-independent documentation strings live here. Everything
+ * application-specific — icons, display labels, keyboard shortcuts, menu
+ * visibility, per-slot editor config (`rhs`), availability policy — is
+ * layered on by the host (Adaptable's
+ * `AdaptableExpressionFunctionEnhancement`), never declared in aql.
+ *
+ * `TContext` is the context type the handler is written against. Hosts
+ * instantiate it with their own extended public context (e.g. Adaptable's
+ * `AdaptableExpressionContext`); the default is aql's host-agnostic
+ * {@link ExpressionContext}.
+ */
+export interface ExpressionFunction<TContext extends ExpressionContext = ExpressionContext> {
+    /**
+     * Actual AQL Function called by the Expression (mandatory).
+     *
+     * Declared with *method* syntax intentionally: method parameters are
+     * checked bivariantly even under `strictFunctionTypes`, so a registry
+     * typed `ExpressionFunctionMap<HostContext>` accepts both handlers
+     * written against the plain public context (always safe) and handlers
+     * written against a richer host context (safe because the host controls
+     * the evaluation context it passes). Do not convert this to a property
+     * arrow signature — that re-introduces contravariant checking and forces
+     * casts on every host registry.
+     */
+    handler(args: unknown[], context: TContext): unknown;
+    /**
+     * Whether Expression is evaluated without handling inner AST nodes
+     */
+    hasEagerEvaluation?: boolean;
+    /**
+     * Context capabilities the handler cannot work without (it throws when
+     * they are missing). Hosts derive availability from this — see
+     * {@link AqlContextRequirement}.
+     */
+    requires?: AqlContextRequirement[];
+    /**
+     * The handler reads the clock (`NOW()`, `IS_PAST`, …): its value can change
+     * without any data change. Consumers containing a time-volatile function
+     * are re-evaluated on the host's clock cadence.
+     */
+    isTimeVolatile?: boolean;
+    /**
+     * Type returned by the Function. Prefer {@link EXPRESSION_RETURN_TYPES}.
+     * Required for custom scalar registrations (see AdapTable
+     * `customStandardFunctions`); optional on some system / aggregated defs.
+     */
+    returnType?: ExpressionReturnType;
+    /**
+     * Operand type matrix: arity + operand types per overload. Boolean
+     * functions include the column first unless {@link appliesTo} is `'row'`.
+     * Drives predicate lowering, draft completeness, and the DEFAULT
+     * QueryBuilder slot resolution — hosts may refine the resulting editor
+     * slots via host-side `rhs` config, which is no longer part of this
+     * interface.
+     */
+    operands?: Overload[];
+    /**
+     * When true, static validation rejects known-wrong argument types / arity
+     * against {@link operands}. Opt-in per function as definitions are audited.
+     */
+    enforceOperandTypes?: boolean;
+    /**
+     * Boolean operators only. Where the predicate attaches.
+     * Omit for the usual case: first {@link operands} entry is a column /
+     * field / `$SCOPE` (`[price] > 5`, `IS_BLANK([col])`).
+     * - `'row'` — no column; every operand is a call argument (`ANY_CONTAINS("x")`)
+     * - `'column-or-row'` — both (`ANY_CHANGE()` and `ANY_CHANGE([col])`)
+     */
+    appliesTo?: 'row' | 'column-or-row';
+    /**
+     * What the function evaluates to (outcome), shown in editor documentation.
+     * Often starts with "Returns …" (e.g. `Returns true if the 1st input
+     * starts with the 2nd`).
+     */
+    description?: string;
+    /**
+     * Call forms shown in editor documentation
+     * (e.g. `CONCAT(value1, value2, ...)`).
+     */
+    signatures?: string[];
+    /**
+     * Sample expressions shown in editor documentation
+     * (e.g. `CONCAT([stringCol], " - ", [stringCol])`).
+     */
+    examples?: string[];
+    /**
+     * Menu grouping in the Expression Editor. Prefer
+     * {@link EXPRESSION_CATEGORIES} / {@link OfficialExpressionCategory} for
+     * autocomplete (`'date'`, `'custom'`, …). Omit or use `'custom'` for the
+     * Custom menu; any other string creates a menu with that name.
+     */
+    category?: ExpressionCategory;
+}
+/**
+ * Handler signature for Expression Functions — including user-defined
+ * `customStandardFunctions`. Receives the **public** {@link ExpressionContext}
+ * (or the host's extension of it) so internals (`functions`, `argNodes`, …)
+ * are not part of the contract.
+ */
+export type ExpressionFunctionHandler<TContext extends ExpressionContext = ExpressionContext> = (args: unknown[], context: TContext) => unknown;
+/**
+ * Handler signature for system / host functions that need internal fields.
+ * Prefer this inside `@adaptabletools/aql` and Adaptable system registries;
+ * do not use it on the public `ExpressionFunction.handler` type.
+ */
+export type InternalExpressionFunctionHandler = ExpressionFunctionHandler<InternalExpressionContext>;
+export declare const isAST_Function: (node: AST_Expression) => node is AST_Function;
+/**
+ * Column id when the arg was a direct `[col]` / `COL("col")` reference,
+ * otherwise `undefined` (e.g. literals or computed args like
+ * `LOWER([make])`). Use with `context.argNodes` from an expression-function
+ * handler to recover subject provenance / fetch raw cell values.
+ */
+export declare const getExpressionArgColumnId: (argNode: AST_Expression | undefined) => string | undefined;
+//# sourceMappingURL=types.d.ts.map

package/vendor/aql/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}