@svgrid/enterprise 2.6.1 → 2.6.2

package/dist/designer/index.html

@@ -4,11 +4,11 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>SvGrid Studio - Designer</title>
-    <script type="module" crossorigin src="./assets/index-CKdwDseq.js"></script>
+    <script type="module" crossorigin src="./assets/index-xjfKckuH.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/rolldown-runtime-Dd_uD5pT.js">
     <link rel="modulepreload" crossorigin href="./assets/disclose-version-CIm4S9xS.js">
     <link rel="modulepreload" crossorigin href="./assets/export-format-DwjuTfrQ.js">
-    <link rel="modulepreload" crossorigin href="./assets/js-scroller.svelte-tHanKJx0.js">
+    <link rel="modulepreload" crossorigin href="./assets/js-scroller.svelte-CGkUUXwV.js">
     <link rel="modulepreload" crossorigin href="./assets/dismissable-2EZKoens.js">
     <link rel="modulepreload" crossorigin href="./assets/popover-CUkLsvRX.js">
     <link rel="modulepreload" crossorigin href="./assets/SvDateTimePicker-DOBYyLeN.js">
@@ -16,13 +16,13 @@
     <link rel="modulepreload" crossorigin href="./assets/easing-zaypKrr0.js">
     <link rel="modulepreload" crossorigin href="./assets/chart-DHEgt4lN.js">
     <link rel="modulepreload" crossorigin href="./assets/SvGridChart-BEDNTdc5.js">
-    <link rel="modulepreload" crossorigin href="./assets/src-DLsSdh3J.js">
-    <link rel="modulepreload" crossorigin href="./assets/SvListBox-BVzVfCG3.js">
+    <link rel="modulepreload" crossorigin href="./assets/src-DDhAK0WP.js">
+    <link rel="modulepreload" crossorigin href="./assets/SvListBox-BB8rt4aP.js">
     <link rel="stylesheet" crossorigin href="./assets/dismissable-BF-9TJSd.css">
     <link rel="stylesheet" crossorigin href="./assets/SvDateTimePicker-Cygij-dr.css">
     <link rel="stylesheet" crossorigin href="./assets/SvGridDropdown-Crwb2P3Q.css">
     <link rel="stylesheet" crossorigin href="./assets/SvGridChart-Vu4Nvjiv.css">
-    <link rel="stylesheet" crossorigin href="./assets/src-DCKhP5Xy.css">
+    <link rel="stylesheet" crossorigin href="./assets/src-BT3LjWJL.css">
     <link rel="stylesheet" crossorigin href="./assets/SvListBox-BMSfFJJT.css">
     <link rel="stylesheet" crossorigin href="./assets/index-BfzoL904.css">
   </head>

package/dist/expressions/builder-tree.d.ts

@@ -0,0 +1,62 @@
+/**
+ * builder-tree - the shape the structured filter builder edits, and its
+ * conversion to and from `PredicateExpr`.
+ *
+ * The builder used to be flat: one combinator over a list of comparisons.
+ * That covers "region is EMEA AND arr > 50000" but not the query people
+ * actually reach for next - "EMEA accounts, OR any account over 300k that is
+ * also high risk" - which needs a group nested inside the top-level list. Any
+ * such expression fell back to text mode, and the Builder tab was disabled.
+ *
+ * A tree makes those expressible. Two boundaries are deliberate:
+ *
+ *   - `scalarCmp` (column maths, aggregates) has no place in a
+ *     column/operator/value row, so it still forces text mode. That is a
+ *     property of the expression, not a missing feature.
+ *   - `not` is representable, but only as a group. Negating a single condition
+ *     is better said with the negative operator the grid already has
+ *     (`notEquals`, `notContains`), so a `not` around one `cmp` is left to text
+ *     mode rather than growing a second way to say the same thing.
+ *
+ * Kept as a pure module so the conversion is unit-testable without mounting a
+ * component, and so the round-trip property can be asserted directly.
+ */
+import type { ExcelFilterOperator } from '@svgrid/grid';
+import { type ExprColumn } from './expression-columns';
+import type { PredicateExpr } from './expression-types';
+/** One column/operator/value row. */
+export type BuilderCondition = {
+    kind: 'cond';
+    column: string;
+    op: ExcelFilterOperator;
+    /** Single value, and the low end of a range operator. */
+    value: string;
+    /** High end of a range operator (`between`). */
+    valueTo: string;
+    /** Values for a set operator (`in`, `notIn`). */
+    values: string[];
+};
+/** A combinator over children, which may themselves be groups. */
+export type BuilderGroup = {
+    kind: 'group';
+    combinator: 'and' | 'or';
+    /** Wrap the whole group in `not`. */
+    negated: boolean;
+    children: BuilderNode[];
+};
+export type BuilderNode = BuilderCondition | BuilderGroup;
+/** How deep the UI allows nesting. */
+export declare const MAX_BUILDER_DEPTH = 4;
+/** A blank condition on the first column, with that column's first operator. */
+export declare function freshCondition(columns: ReadonlyArray<ExprColumn>): BuilderCondition;
+/** A blank group holding one blank condition. */
+export declare function freshGroup(columns: ReadonlyArray<ExprColumn>, combinator?: 'and' | 'or'): BuilderGroup;
+/**
+ * The whole expression as a builder tree, or null if it must stay text.
+ *
+ * The result is always a group, so the UI has a single root to render even
+ * when the expression is one bare comparison.
+ */
+export declare function toBuilderTree(expr: PredicateExpr, columns: ReadonlyArray<ExprColumn>): BuilderGroup | null;
+/** The builder tree back to an expression. An empty tree means "no filter". */
+export declare function fromBuilderTree(root: BuilderGroup): PredicateExpr;

package/dist/expressions/builder-tree.js

@@ -0,0 +1,133 @@
+import { isRangeOperator, isSetOperator, isValueless, operatorsForType, } from './expression-columns';
+/** How deep the UI allows nesting. */
+export const MAX_BUILDER_DEPTH = 4;
+/** A blank condition on the first column, with that column's first operator. */
+export function freshCondition(columns) {
+    const first = columns[0];
+    const ops = operatorsForType(first?.type);
+    return {
+        kind: 'cond',
+        column: first?.id ?? '',
+        op: ops[0]?.value ?? 'equals',
+        value: '',
+        valueTo: '',
+        values: [],
+    };
+}
+/** A blank group holding one blank condition. */
+export function freshGroup(columns, combinator = 'and') {
+    return {
+        kind: 'group',
+        combinator,
+        negated: false,
+        children: [freshCondition(columns)],
+    };
+}
+function conditionFromCmp(p) {
+    return {
+        kind: 'cond',
+        column: p.column,
+        op: p.op,
+        value: p.value != null && !Array.isArray(p.value) ? String(p.value) : '',
+        valueTo: p.valueTo != null ? String(p.valueTo) : '',
+        values: Array.isArray(p.value) ? p.value.map(String) : [],
+    };
+}
+/**
+ * One node of the expression to one node of the builder, or null when the
+ * expression cannot be shown as a condition row or a group.
+ *
+ * `depth` guards against an expression nested deeper than the UI can render.
+ * Rather than draw a tree the user cannot fully see, such an expression stays
+ * in text mode where it is at least intact and editable.
+ */
+function nodeFrom(expr, depth) {
+    if (depth > MAX_BUILDER_DEPTH)
+        return null;
+    switch (expr.kind) {
+        case 'cmp':
+            return conditionFromCmp(expr);
+        case 'and':
+        case 'or': {
+            const children = [];
+            for (const part of expr.parts) {
+                const child = nodeFrom(part, depth + 1);
+                if (!child)
+                    return null;
+                children.push(child);
+            }
+            return {
+                kind: 'group',
+                combinator: expr.kind,
+                negated: false,
+                children,
+            };
+        }
+        case 'not': {
+            // Only a negated GROUP round-trips. `not` around one comparison is said
+            // better by the operator itself, so it stays in text mode.
+            const inner = expr.expr;
+            if (inner.kind !== 'and' && inner.kind !== 'or')
+                return null;
+            const group = nodeFrom(inner, depth);
+            if (!group || group.kind !== 'group')
+                return null;
+            return { ...group, negated: true };
+        }
+        default:
+            // const / scalarCmp: no condition-row representation.
+            return null;
+    }
+}
+/**
+ * The whole expression as a builder tree, or null if it must stay text.
+ *
+ * The result is always a group, so the UI has a single root to render even
+ * when the expression is one bare comparison.
+ */
+export function toBuilderTree(expr, columns) {
+    // `const true` is how "no filter yet" is spelled. Show it as an empty
+    // builder rather than an unrepresentable expression, so a fresh panel opens
+    // on a ready-to-fill row instead of dropping into text mode showing `true`.
+    if (expr.kind === 'const') {
+        return expr.value ? freshGroup(columns) : null;
+    }
+    const node = nodeFrom(expr, 0);
+    if (!node)
+        return null;
+    if (node.kind === 'cond') {
+        return { kind: 'group', combinator: 'and', negated: false, children: [node] };
+    }
+    return node;
+}
+function cmpFromCondition(c) {
+    const base = { kind: 'cmp', column: c.column, op: c.op };
+    if (isValueless(c.op))
+        return base;
+    if (isSetOperator(c.op))
+        return { ...base, value: c.values };
+    if (isRangeOperator(c.op))
+        return { ...base, value: c.value, valueTo: c.valueTo };
+    return { ...base, value: c.value };
+}
+function nodeTo(node) {
+    if (node.kind === 'cond')
+        return cmpFromCondition(node);
+    const parts = [];
+    for (const child of node.children) {
+        const part = nodeTo(child);
+        // An empty group contributes nothing rather than collapsing the whole
+        // expression - a half-built group in the UI must not silently change what
+        // the finished filter means.
+        if (part)
+            parts.push(part);
+    }
+    if (parts.length === 0)
+        return null;
+    const inner = parts.length === 1 ? parts[0] : { kind: node.combinator, parts };
+    return node.negated ? { kind: 'not', expr: inner } : inner;
+}
+/** The builder tree back to an expression. An empty tree means "no filter". */
+export function fromBuilderTree(root) {
+    return nodeTo(root) ?? { kind: 'const', value: true };
+}

package/dist/expressions/compile.d.ts

@@ -0,0 +1,14 @@
+import type { PredicateExpr, ScalarExpr } from './expression-types';
+type Scalar = number | string | boolean | null;
+export type CompileOptions<TRow> = {
+    getValue: (row: TRow, columnId: string) => unknown;
+    locale?: string | ReadonlyArray<string>;
+    /** Rows the aggregates fold over. */
+    rows: ReadonlyArray<TRow>;
+    functions?: Record<string, (args: Scalar[]) => Scalar>;
+};
+/** Compile a predicate. Returns null when the expression is unusable. */
+export declare function compilePredicate<TRow>(expr: PredicateExpr, opts: CompileOptions<TRow>): ((row: TRow) => boolean) | null;
+/** Compile a scalar expression on its own (aggregates folded over `opts.rows`). */
+export declare function compileScalar<TRow>(expr: ScalarExpr, opts: CompileOptions<TRow>): (row: TRow) => Scalar;
+export {};

package/dist/expressions/compile.js

@@ -0,0 +1,286 @@
+/**
+ * Compile a predicate expression into a row predicate.
+ *
+ * `evaluate.ts` walks the AST for every row. That is fine for alert rules,
+ * which run over a handful of changed rows, and wrong for a grid filter, which
+ * runs over the whole dataset on every keystroke. This module does the walk
+ * once and returns a closure tree.
+ *
+ * Two properties are load-bearing:
+ *
+ *   1. **Identical semantics.** Leaf comparisons go through the grid's own
+ *      `compileExcelFilter`, the same code path the column-menu filter uses, so
+ *      an advanced filter and a column filter agree by construction.
+ *      `compile.test.ts` asserts the compiled result matches `evaluatePredicate`
+ *      across a corpus, so the compiler's correctness is a consequence of the
+ *      evaluator's rather than a parallel claim.
+ *
+ *   2. **Aggregates fold once.** `evaluateScalar`'s `agg` case rescans every row
+ *      for every row, so `SUM(amount) > 1000` is O(N^2). Here the distinct
+ *      aggregates are computed in a single pass up front and compiled to
+ *      constants.
+ */
+import { compileExcelFilter } from '@svgrid/grid/filtering';
+const num = (v) => typeof v === 'number' ? v : v == null || v === '' ? NaN : Number(v);
+const BUILTINS = {
+    ABS: (a) => Math.abs(num(a[0])),
+    ROUND: (a) => Math.round(num(a[0])),
+    FLOOR: (a) => Math.floor(num(a[0])),
+    CEIL: (a) => Math.ceil(num(a[0])),
+    MIN: (a) => Math.min(...a.map(num)),
+    MAX: (a) => Math.max(...a.map(num)),
+    IF: (a) => (a[0] ? (a[1] ?? null) : (a[2] ?? null)),
+    COALESCE: (a) => a.find((v) => v != null) ?? null,
+    CONCAT: (a) => a.map((v) => (v == null ? '' : String(v))).join(''),
+    LOWER: (a) => String(a[0] ?? '').toLowerCase(),
+    UPPER: (a) => String(a[0] ?? '').toUpperCase(),
+    LEN: (a) => String(a[0] ?? '').length,
+};
+/**
+ * Fold every `agg` node in the tree to a constant, in ONE pass over the rows.
+ * Returns a key -> value map; the key is `fn:column`.
+ */
+function foldAggregates(expr, opts) {
+    const wanted = new Set();
+    const columns = new Set();
+    const scanScalar = (s) => {
+        switch (s.kind) {
+            case 'agg':
+                wanted.add(`${s.fn}:${s.column}`);
+                if (s.fn !== 'count')
+                    columns.add(s.column);
+                break;
+            case 'neg':
+                scanScalar(s.expr);
+                break;
+            case 'bin':
+                scanScalar(s.left);
+                scanScalar(s.right);
+                break;
+            case 'func':
+                s.args.forEach(scanScalar);
+                break;
+            default:
+                break;
+        }
+    };
+    const scan = (p) => {
+        switch (p.kind) {
+            case 'and':
+            case 'or':
+                p.parts.forEach(scan);
+                break;
+            case 'not':
+                scan(p.expr);
+                break;
+            case 'scalarCmp':
+                scanScalar(p.left);
+                scanScalar(p.right);
+                break;
+            default:
+                break;
+        }
+    };
+    scan(expr);
+    const out = new Map();
+    if (wanted.size === 0)
+        return out; // overwhelmingly the common case
+    // One pass, accumulating per column.
+    const acc = new Map();
+    for (const c of columns)
+        acc.set(c, { sum: 0, n: 0, min: Infinity, max: -Infinity });
+    for (const row of opts.rows) {
+        for (const c of columns) {
+            const n = num(opts.getValue(row, c));
+            if (!Number.isFinite(n))
+                continue;
+            const a = acc.get(c);
+            a.sum += n;
+            a.n += 1;
+            if (n < a.min)
+                a.min = n;
+            if (n > a.max)
+                a.max = n;
+        }
+    }
+    for (const key of wanted) {
+        const [fn, column] = key.split(/:(.*)/s);
+        if (fn === 'count') {
+            out.set(key, opts.rows.length);
+            continue;
+        }
+        const a = acc.get(column);
+        // Matches evaluate.ts: an empty numeric set is 0 for sum, null otherwise.
+        if (!a || a.n === 0) {
+            out.set(key, fn === 'sum' ? 0 : null);
+            continue;
+        }
+        switch (fn) {
+            case 'sum':
+                out.set(key, a.sum);
+                break;
+            case 'avg':
+                out.set(key, a.sum / a.n);
+                break;
+            case 'min':
+                out.set(key, a.min);
+                break;
+            case 'max':
+                out.set(key, a.max);
+                break;
+            default:
+                out.set(key, null);
+        }
+    }
+    return out;
+}
+function compileScalarInternal(expr, opts, aggs) {
+    switch (expr.kind) {
+        case 'lit': {
+            const v = expr.value;
+            return () => v;
+        }
+        case 'col': {
+            const id = expr.id;
+            return (row) => {
+                const raw = opts.getValue(row, id);
+                return (raw ?? null);
+            };
+        }
+        case 'neg': {
+            const inner = compileScalarInternal(expr.expr, opts, aggs);
+            return (row) => -num(inner(row));
+        }
+        case 'bin': {
+            const l = compileScalarInternal(expr.left, opts, aggs);
+            const r = compileScalarInternal(expr.right, opts, aggs);
+            const op = expr.op;
+            return (row) => {
+                const a = num(l(row));
+                const b = num(r(row));
+                switch (op) {
+                    case '+':
+                        return a + b;
+                    case '-':
+                        return a - b;
+                    case '*':
+                        return a * b;
+                    case '/':
+                        return b === 0 ? NaN : a / b;
+                    case '%':
+                        return b === 0 ? NaN : a % b;
+                    default:
+                        return null;
+                }
+            };
+        }
+        case 'agg': {
+            // Already folded to a constant.
+            const v = aggs.get(`${expr.fn}:${expr.column}`) ?? null;
+            return () => v;
+        }
+        case 'func': {
+            const name = expr.name.toUpperCase();
+            const args = expr.args.map((a) => compileScalarInternal(a, opts, aggs));
+            const fn = opts.functions?.[name] ?? BUILTINS[name];
+            if (!fn)
+                return () => null;
+            return (row) => fn(args.map((a) => a(row)));
+        }
+        default:
+            return () => null;
+    }
+}
+function compareScalars(a, op, b) {
+    // Numeric when both sides look numeric, else string - mirrors evaluate.ts.
+    const na = num(a);
+    const nb = num(b);
+    const numeric = Number.isFinite(na) && Number.isFinite(nb);
+    const x = numeric ? na : String(a ?? '');
+    const y = numeric ? nb : String(b ?? '');
+    switch (op) {
+        case '=':
+            return x === y;
+        case '!=':
+            return x !== y;
+        case '>':
+            return x > y;
+        case '<':
+            return x < y;
+        case '>=':
+            return x >= y;
+        case '<=':
+            return x <= y;
+        default:
+            return false;
+    }
+}
+function compileInternal(expr, opts, aggs) {
+    switch (expr.kind) {
+        case 'const': {
+            const v = expr.value === true;
+            return () => v;
+        }
+        case 'and': {
+            const parts = expr.parts.map((p) => compileInternal(p, opts, aggs));
+            if (parts.length === 0)
+                return () => true;
+            return (row) => {
+                for (const p of parts)
+                    if (!p(row))
+                        return false;
+                return true;
+            };
+        }
+        case 'or': {
+            const parts = expr.parts.map((p) => compileInternal(p, opts, aggs));
+            if (parts.length === 0)
+                return () => false;
+            return (row) => {
+                for (const p of parts)
+                    if (p(row))
+                        return true;
+                return false;
+            };
+        }
+        case 'not': {
+            const inner = compileInternal(expr.expr, opts, aggs);
+            return (row) => !inner(row);
+        }
+        case 'cmp': {
+            // The needle-side work happens once, here.
+            const test = compileExcelFilter({
+                id: expr.column,
+                operator: expr.op,
+                value: expr.value,
+                valueTo: expr.valueTo,
+            }, { locale: opts.locale });
+            const column = expr.column;
+            return (row) => test(opts.getValue(row, column));
+        }
+        case 'scalarCmp': {
+            const l = compileScalarInternal(expr.left, opts, aggs);
+            const r = compileScalarInternal(expr.right, opts, aggs);
+            const op = expr.op;
+            return (row) => compareScalars(l(row), op, r(row));
+        }
+        default:
+            // Unknown node kind (hand-edited JSON): match nothing rather than throw.
+            return () => false;
+    }
+}
+/** Compile a predicate. Returns null when the expression is unusable. */
+export function compilePredicate(expr, opts) {
+    try {
+        const aggs = foldAggregates(expr, opts);
+        return compileInternal(expr, opts, aggs);
+    }
+    catch {
+        return null;
+    }
+}
+/** Compile a scalar expression on its own (aggregates folded over `opts.rows`). */
+export function compileScalar(expr, opts) {
+    const aggs = foldAggregates({ kind: 'scalarCmp', left: expr, op: '=', right: expr }, opts);
+    return compileScalarInternal(expr, opts, aggs);
+}

package/dist/expressions/expression-columns.d.ts

@@ -1,13 +1,3 @@
-/**
- * Column metadata for the expression layer - the small, self-contained operator
- * catalogue the editor draws from, plus name <-> id resolution for the
- * `[Bracketed Name]` reference syntax.
- *
- * The operator set mirrors the grid's own filter row (text / number / date),
- * so an expression's operators line up with what a user already knows from the
- * column menu. We keep a local copy rather than importing the grid's internal
- * `filter-operators` module (which is not part of the public surface).
- */
 import type { ExcelFilterOperator } from '@svgrid/grid';
 /** Coarse value type used to decide which operators a column offers. */
 export type ExprColumnType = 'text' | 'number' | 'date' | 'datetime' | 'boolean';
@@ -37,7 +27,7 @@ export declare const OPERATORS: ReadonlyArray<OperatorMeta>;
 export declare function operatorMeta(op: ExcelFilterOperator): OperatorMeta;
 /** Operators valid for a column type (defaults to the text set). */
 export declare function operatorsForType(type: ExprColumnType | undefined): OperatorMeta[];
-/** Whether an operator needs no value input. */
+/** Whether an operator needs no value input. Delegates to the grid catalogue. */
 export declare function isValueless(op: ExcelFilterOperator): boolean;
 /** Whether an operator takes a multi-value token list. */
 export declare function isSetOperator(op: ExcelFilterOperator): boolean;

package/dist/expressions/expression-columns.js

@@ -1,9 +1,31 @@
+/**
+ * Column metadata for the expression layer - the small, self-contained operator
+ * catalogue the editor draws from, plus name <-> id resolution for the
+ * `[Bracketed Name]` reference syntax.
+ *
+ * The operator set mirrors the grid's own filter row (text / number / date),
+ * so an expression's operators line up with what a user already knows from the
+ * column menu.
+ *
+ * Identity and input-shape semantics come from the grid's shared catalogue, so
+ * the two surfaces cannot disagree about which operators exist or which need a
+ * chip input / no input / a second value. Labels and ordering stay local on
+ * purpose: the editor leads with `Equals` where the filter menu leads with
+ * `Contains`, and each is right for its context.
+ */
+// Imported from the `/filtering` subpath, not the package root: the root would
+// drag SvGrid.svelte into a module that is otherwise pure logic.
+import { isRangeOperator as gridIsRangeOperator, isSetOperator as gridIsSetOperator, isValuelessOperator as gridIsValuelessOperator, } from '@svgrid/grid/filtering';
 const TEXT = ['text'];
 const NUM = ['number'];
 const DATES = ['date', 'datetime'];
 const ALL = ['text', 'number', 'date', 'datetime', 'boolean'];
-/** The full operator catalogue, ordered as the editor should present it. */
-export const OPERATORS = [
+/**
+ * Label + type applicability are local (presentation); the `valueless` / `set` /
+ * `range` flags are stamped on from the grid's shared catalogue below, so the
+ * editor can never render the wrong input control for an operator.
+ */
+const OPERATOR_PRESENTATION = [
     { value: 'equals', label: 'Equals', types: ALL },
     { value: 'notEquals', label: 'Not equals', types: ALL },
     { value: 'contains', label: 'Contains', types: TEXT },
@@ -13,12 +35,19 @@ export const OPERATORS = [
     { value: 'regex', label: 'Matches regex', types: TEXT },
     { value: 'greaterThan', label: 'Greater than', types: [...NUM, ...DATES] },
     { value: 'lessThan', label: 'Less than', types: [...NUM, ...DATES] },
-    { value: 'between', label: 'Between', types: [...NUM, ...DATES], range: true },
-    { value: 'in', label: 'In', types: ['text', 'number'], set: true },
-    { value: 'notIn', label: 'Not in', types: ['text', 'number'], set: true },
-    { value: 'isBlank', label: 'Is blank', types: ALL, valueless: true },
-    { value: 'isNotBlank', label: 'Is not blank', types: ALL, valueless: true },
+    { value: 'between', label: 'Between', types: [...NUM, ...DATES] },
+    { value: 'in', label: 'In', types: ['text', 'number'] },
+    { value: 'notIn', label: 'Not in', types: ['text', 'number'] },
+    { value: 'isBlank', label: 'Is blank', types: ALL },
+    { value: 'isNotBlank', label: 'Is not blank', types: ALL },
 ];
+/** The full operator catalogue, ordered as the editor should present it. */
+export const OPERATORS = OPERATOR_PRESENTATION.map((op) => ({
+    ...op,
+    ...(gridIsValuelessOperator(op.value) ? { valueless: true } : {}),
+    ...(gridIsSetOperator(op.value) ? { set: true } : {}),
+    ...(gridIsRangeOperator(op.value) ? { range: true } : {}),
+}));
 const BY_VALUE = new Map(OPERATORS.map((op) => [op.value, op]));
 /** Metadata for one operator (falls back to a plain `equals`). */
 export function operatorMeta(op) {
@@ -29,17 +58,17 @@ export function operatorsForType(type) {
     const t = type ?? 'text';
     return OPERATORS.filter((op) => op.types.includes(t));
 }
-/** Whether an operator needs no value input. */
+/** Whether an operator needs no value input. Delegates to the grid catalogue. */
 export function isValueless(op) {
-    return operatorMeta(op).valueless === true;
+    return gridIsValuelessOperator(op);
 }
 /** Whether an operator takes a multi-value token list. */
 export function isSetOperator(op) {
-    return operatorMeta(op).set === true;
+    return gridIsSetOperator(op);
 }
 /** Whether an operator needs a second (`valueTo`) value. */
 export function isRangeOperator(op) {
-    return operatorMeta(op).range === true;
+    return gridIsRangeOperator(op);
 }
 /** Look a column up by its canonical id. */
 export function columnById(columns, id) {

package/dist/index.d.ts

@@ -10,6 +10,10 @@ export { installEnterprise, type EnterpriseGridApi, type EnterpriseAIApi, type E
 export { enableSchedulerView, SvGridScheduler } from './scheduler';
 export { enableBoardView, SvGridBoard } from './board';
 export { enablePivot } from './pivot-enable';
+export { enableAdvancedFilter } from './advanced-filter-enable';
+export { default as SvAdvancedFilter } from './SvAdvancedFilter.svelte';
+export { exprColumnsFromGrid, type ExprColumnsOptions, } from './advanced-filter/expr-columns-from-grid';
+export { compilePredicate, compileScalar, type CompileOptions, } from './expressions/compile';
 export type { SchedulerProConfig } from './scheduler-config';
 export { buildDependencyGraph, topoOrder, hasCycle, requiredStart, cascade, violations, type DependencyType, type SchedulerDependency, type EventTimes, type DependencyGraph, type CascadeOptions, } from './scheduler-dependencies';
 export { expandAssignments, resourceLoad, overallocations, assignedMinutes, type SchedulerAssignment, type Allocation, type Overallocation, } from './scheduler-assignments';

package/dist/index.js

@@ -20,6 +20,10 @@ export { enableBoardView, SvGridBoard } from './board';
 // In-grid pivot mode (Pro). `enablePivot()` registers the pivot engine so
 // `<SvGrid pivot={...}>` renders a pivot table in place of the flat table.
 export { enablePivot } from './pivot-enable';
+export { enableAdvancedFilter } from './advanced-filter-enable';
+export { default as SvAdvancedFilter } from './SvAdvancedFilter.svelte';
+export { exprColumnsFromGrid, } from './advanced-filter/expr-columns-from-grid';
+export { compilePredicate, compileScalar, } from './expressions/compile';
 export { buildDependencyGraph, topoOrder, hasCycle, requiredStart, cascade, violations, } from './scheduler-dependencies';
 export { expandAssignments, resourceLoad, overallocations, assignedMinutes, } from './scheduler-assignments';
 export { columnSummaries, sumReducer, countReducer, busyMinutesReducer, } from './scheduler-summary';

package/dist/install.js

@@ -9,6 +9,7 @@ import { aiFilter, aiSmartFill, aiSummarize, aiClassify, aiExport, aiFindAnomali
 import { createPivotModel, } from './pivot';
 import { enableSchedulerView } from './scheduler';
 import { enableBoardView } from './board';
+import { enableAdvancedFilter } from './advanced-filter-enable';
 import { enablePivot } from './pivot-enable';
 /**
  * Augment a SvGridApi instance with Pro methods (`exportData`, `print`,
@@ -45,6 +46,7 @@ export function installEnterprise(api) {
     // enterprise formats (xlsx / pdf / ...); free grids without it get the plan only.
     registerExportProvider(exportGrid);
     enablePivot();
+    enableAdvancedFilter();
     pro.pivot = {
         build: (config) => createPivotModel(pro.getData(), config),
         buildFrom: (data, config) =>