@zengrid/core 1.2.1 → 1.2.2

package/dist/index.esm.js

@@ -11574,10 +11574,18 @@ class GridApiImpl {
 }
 
 class PluginHost {
-    constructor(store, api) {
+    constructor(store, api, setupContext) {
         this.store = store;
         this.api = api;
         this.plugins = new Map();
+        const options = setupContext?.options ?? {};
+        this.setupContext = setupContext ?? {
+            options,
+            getOptions: () => options,
+            getOptionsSnapshot: () => ({ ...options }),
+            updateOptions: () => null,
+            subscribeOptions: () => () => { },
+        };
     }
     use(plugin) {
         if (this.plugins.has(plugin.name)) {
@@ -11593,7 +11601,7 @@ class PluginHost {
         const entry = { plugin };
         this.plugins.set(plugin.name, entry);
         const start = performance.now();
-        const disposable = plugin.setup(this.store, this.api);
+        const disposable = plugin.setup(this.store, this.api, this.setupContext);
         const duration = performance.now() - start;
         recordPluginTiming(plugin.name, duration);
         if (disposable) {
@@ -11658,6 +11666,13 @@ function createCorePlugin(options) {
     };
 }
 
+function resolveQueryExecutionMode(mode) {
+    return mode === 'backend' ? 'backend' : 'frontend';
+}
+function shouldDelegateQueryState(mode) {
+    return resolveQueryExecutionMode(mode) === 'backend';
+}
+
 function toggleSortState(currentState, column, enableMultiSort, additive) {
     const nextState = currentState.map((entry) => ({ ...entry }));
     if (!enableMultiSort || !additive) {
@@ -11694,7 +11709,7 @@ function createSortPlugin(options) {
         name: 'sort',
         phase: 10,
         dependencies: ['core'],
-        setup(store, api) {
+        setup(store, api, context) {
             const usePipeline = options?.usePipeline !== false;
             const initialSort = normalizeSortState(options?.initialSort ?? []);
             const enableMultiSort = options?.enableMultiSort ?? false;
@@ -11712,9 +11727,8 @@ function createSortPlugin(options) {
                     initialSort,
                 });
             }
-            function getDataMode() {
-                const getMode = api.getMethod('data', 'getMode');
-                return getMode ? getMode() : 'frontend';
+            function getQueryMode() {
+                return resolveQueryExecutionMode(context.options.dataMode);
             }
             function syncToStore() {
                 if (!usePipeline || !mgr) {
@@ -11799,7 +11813,7 @@ function createSortPlugin(options) {
                     return sortState.find((entry) => entry.column === column)?.direction ?? null;
                 },
                 getIcons: () => ({ asc: '▲', desc: '▼' }),
-                getMode: () => getDataMode(),
+                getMode: () => getQueryMode(),
             });
             if (usePipeline && initialSort.length) {
                 syncToStore();
@@ -11811,6 +11825,13 @@ function createSortPlugin(options) {
     };
 }
 
+function buildUnexecutableFilterError(warnings = []) {
+    const detail = warnings.filter(Boolean).join(' ');
+    return new Error(detail
+        ? `Structured filter cannot be executed in frontend mode. ${detail}`
+        : 'Structured filter cannot be executed in frontend mode.');
+}
+
 /**
  * FilterCompiler - Compiles filter conditions to optimized predicates
  *
@@ -12224,10 +12245,16 @@ function buildFilterAstFromModels(models, options = {}) {
         return null;
     }
     const children = models
-        .map((model) => modelToAstNode(model, options.columns))
+        .map((model) => buildFilterAstNodeFromModel(model, options))
         .filter((node) => node !== null);
     return createFilterAst(children, 'AND', 'model');
 }
+function buildFilterAstNodeFromModel(model, options = {}) {
+    return modelToAstNode(model, options.columns);
+}
+function buildFilterAstFromNodes(nodes, options = {}) {
+    return createFilterAst(nodes ?? [], options.logic ?? 'AND', options.source ?? 'api');
+}
 function buildFilterAstFromFieldState(state, options = {}) {
     if (!state?.root) {
         return null;
@@ -12237,24 +12264,6 @@ function buildFilterAstFromFieldState(state, options = {}) {
         root: fieldGroupToAstGroup(state.root, options.columns),
     };
 }
-function buildFilterAstFromSqlQuery(query, options = {}) {
-    const node = {
-        kind: 'sql',
-        source: 'sql',
-        sql: query.sql,
-        boundSql: options.boundSql,
-        params: options.params ? [...options.params] : undefined,
-    };
-    return {
-        version: 1,
-        root: {
-            kind: 'group',
-            logic: 'AND',
-            children: [node],
-            source: 'sql',
-        },
-    };
-}
 function buildFilterAst(options) {
     const nodes = [];
     const baseAst = options.ast?.root
@@ -12263,12 +12272,7 @@ function buildFilterAst(options) {
             ? buildFilterAstFromFieldState(options.fieldState, options)
             : options.models && options.models.length > 0
                 ? buildFilterAstFromModels(options.models, options)
-                : options.sqlQuery?.sql
-                    ? buildFilterAstFromSqlQuery(options.sqlQuery, {
-                        boundSql: options.boundSql,
-                        params: options.params,
-                    })
-                    : null;
+                : null;
     if (baseAst?.root) {
         nodes.push(baseAst.root);
     }
@@ -12551,7 +12555,7 @@ function collectActiveFields(group, activeFields) {
     }
 }
 function normalizeConditionValue(operator, value) {
-    if (operator === 'between' && Array.isArray(value)) {
+    if (operator === 'between' && Array.isArray(value) && value.length >= 2) {
         return {
             value: value[0],
             valueTo: value[1],
@@ -12662,7 +12666,12 @@ class FilterAstCompiler {
         this.conditionCompiler = new FilterCompiler();
         this.colCount = options.colCount;
         this.getValue = options.getValue;
-        this.columns = options.columns;
+        this.fieldToColumn = new Map();
+        options.columns?.forEach((column, index) => {
+            if (column.field) {
+                this.fieldToColumn.set(column.field, index);
+            }
+        });
     }
     compile(ast) {
         const warnings = [];
@@ -12707,9 +12716,6 @@ class FilterAstCompiler {
                 }
                 return (row) => !child(row);
             }
-            case 'sql':
-                warnings.push('SQL AST nodes cannot be executed in frontend filtering.');
-                return null;
         }
     }
     compilePredicateNode(node, warnings) {
@@ -12734,15 +12740,33 @@ class FilterAstCompiler {
         if (!columns || columns.length === 0) {
             return null;
         }
+        const requiresJoinedSearch = /\s/.test(query);
+        if (!requiresJoinedSearch) {
+            return (row) => {
+                for (const column of columns) {
+                    const value = this.getValue(row, column);
+                    if (value !== undefined &&
+                        value !== null &&
+                        String(value).toLowerCase().includes(query)) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+        }
         return (row) => {
-            const parts = [];
+            let searchableText = '';
             for (const column of columns) {
                 const value = this.getValue(row, column);
                 if (value !== undefined && value !== null) {
-                    parts.push(String(value));
+                    const normalized = String(value).toLowerCase();
+                    if (normalized.includes(query)) {
+                        return true;
+                    }
+                    searchableText = searchableText ? `${searchableText} ${normalized}` : normalized;
                 }
             }
-            return parts.join(' ').toLowerCase().includes(query);
+            return searchableText.includes(query);
         };
     }
     resolveSearchColumns(targets, warnings) {
@@ -12750,13 +12774,17 @@ class FilterAstCompiler {
             return Array.from({ length: this.colCount }, (_, index) => index);
         }
         const columns = [];
+        const seenColumns = new Set();
         for (const target of targets) {
             const column = this.resolveColumn(target);
             if (column === undefined) {
                 warnings.push('AST search target is missing a column reference for frontend execution.');
                 return null;
             }
-            columns.push(column);
+            if (!seenColumns.has(column)) {
+                seenColumns.add(column);
+                columns.push(column);
+            }
         }
         return columns;
     }
@@ -12764,11 +12792,10 @@ class FilterAstCompiler {
         if (typeof target.column === 'number') {
             return target.column;
         }
-        if (!target.field || !this.columns) {
+        if (!target.field) {
             return undefined;
         }
-        const column = this.columns.findIndex((candidate) => candidate.field === target.field);
-        return column >= 0 ? column : undefined;
+        return this.fieldToColumn.get(target.field);
     }
     toFilterCondition(node, warnings) {
         const sourceOperator = typeof node.sourceOperator === 'string' && isSupportedFilterOperator(node.sourceOperator)
@@ -12807,6 +12834,120 @@ function dedupeWarnings$1(warnings) {
     return Array.from(new Set(warnings));
 }
 
+const FNV_OFFSET_BASIS = 0x811c9dc5;
+const FNV_PRIME = 0x01000193;
+function stableHashValue(value) {
+    const hasher = new StableHasher();
+    const seen = new WeakSet();
+    hashValue(hasher, value, seen);
+    return hasher.digest();
+}
+class StableHasher {
+    constructor() {
+        this.hash = FNV_OFFSET_BASIS;
+    }
+    write(token) {
+        for (let index = 0; index < token.length; index += 1) {
+            this.hash ^= token.charCodeAt(index);
+            this.hash = Math.imul(this.hash, FNV_PRIME);
+        }
+    }
+    digest() {
+        return (this.hash >>> 0).toString(16).padStart(8, '0');
+    }
+}
+function hashValue(hasher, value, seen) {
+    if (value === null) {
+        hasher.write('null');
+        return;
+    }
+    if (value === undefined) {
+        hasher.write('undefined');
+        return;
+    }
+    if (value instanceof Date) {
+        hasher.write('date');
+        hasher.write(value.toISOString());
+        return;
+    }
+    if (Array.isArray(value)) {
+        hasher.write('array[');
+        for (const item of value) {
+            hashValue(hasher, item, seen);
+            hasher.write(',');
+        }
+        hasher.write(']');
+        return;
+    }
+    switch (typeof value) {
+        case 'string':
+            hasher.write('string');
+            hasher.write(value);
+            return;
+        case 'number':
+            hasher.write('number');
+            hasher.write(Number.isFinite(value) ? value.toString() : String(value));
+            return;
+        case 'boolean':
+            hasher.write(value ? 'true' : 'false');
+            return;
+        case 'bigint':
+            hasher.write('bigint');
+            hasher.write(value.toString());
+            return;
+        case 'symbol':
+            hasher.write('symbol');
+            hasher.write(value.description ?? '');
+            return;
+        case 'function':
+            hasher.write('function');
+            hasher.write(value.name);
+            return;
+        case 'object':
+            break;
+        default:
+            hasher.write(String(value));
+            return;
+    }
+    if (seen.has(value)) {
+        hasher.write('[Circular]');
+        return;
+    }
+    seen.add(value);
+    hasher.write('{');
+    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+    for (const [key, nested] of entries) {
+        hasher.write(key);
+        hasher.write(':');
+        hashValue(hasher, nested, seen);
+        hasher.write(';');
+    }
+    hasher.write('}');
+    seen.delete(value);
+}
+
+const filterAstSignatureCache = new WeakMap();
+function getFilterAstSignature(ast) {
+    if (!ast?.root) {
+        return '';
+    }
+    const cached = filterAstSignatureCache.get(ast);
+    if (cached) {
+        return cached;
+    }
+    const signature = stableHashValue(ast.root);
+    filterAstSignatureCache.set(ast, signature);
+    return signature;
+}
+function buildFilterStateSignature(executionMode, models, ast) {
+    if (executionMode === 'none' && models.length === 0 && !ast?.root) {
+        return '';
+    }
+    const modelSignature = models.length > 0 ? stableHashValue(models) : '';
+    const astSignature = executionMode === 'column' || executionMode === 'none' ? '' : getFilterAstSignature(ast);
+    return `mode:${executionMode}|models:${modelSignature}|ast:${astSignature}`;
+}
+
 /**
  * FilterCore - Core filter state management
  *
@@ -12816,7 +12957,9 @@ function dedupeWarnings$1(warnings) {
 class FilterCore {
     constructor(colCount, getValue, columns, events, onFilterStateChange) {
         this.columnFilters = new Map();
+        this.columnAstNodes = new Map();
         this.filterState = [];
+        this.filterStateSnapshot = [];
         this.filterStateHash = '';
         this.filterAst = null;
         this.astProjectionWarnings = [];
@@ -12828,6 +12971,7 @@ class FilterCore {
         this.columns = columns;
         this.events = events;
         this.onFilterStateChange = onFilterStateChange;
+        this.astCompiler = this.createAstCompiler();
     }
     /**
      * Initialize with filter models
@@ -12847,8 +12991,9 @@ class FilterCore {
             this.clearColumnFilter(column);
             return;
         }
-        this.columnFilters.set(column, this.createColumnFilter(column, conditions, logic));
-        this.syncStateFromColumnFilters();
+        const filter = this.createColumnFilter(column, conditions, logic);
+        this.columnFilters.set(column, filter);
+        this.syncStateFromColumnModel(filter.getModel());
         this.emitFilterChange();
     }
     /**
@@ -12856,18 +13001,25 @@ class FilterCore {
      */
     setFilterModels(models, options = {}) {
         this.columnFilters.clear();
+        this.columnAstNodes.clear();
+        const nextState = [];
         for (const model of models) {
             if (!model.conditions || model.conditions.length === 0) {
                 continue;
             }
             this.assertColumnInBounds(model.column);
-            this.columnFilters.set(model.column, this.createColumnFilter(model.column, model.conditions, model.logic ?? 'AND'));
-        }
-        this.filterState = Array.from(this.columnFilters.values()).map((filter) => filter.getModel());
+            const filter = this.createColumnFilter(model.column, model.conditions, model.logic ?? 'AND');
+            const nextModel = filter.getModel();
+            this.columnFilters.set(nextModel.column, filter);
+            this.upsertFilterState(nextModel, nextState);
+            this.upsertColumnAstNode(nextModel);
+        }
+        this.filterState = nextState;
+        this.refreshFilterStateSnapshot();
         this.filterAst =
             options.ast !== undefined
                 ? options.ast
-                : buildFilterAstFromModels(this.filterState, { columns: this.columns });
+                : buildFilterAstFromNodes(Array.from(this.columnAstNodes.values()), { source: 'model' });
         this.astProjectionWarnings = dedupeWarnings(options.projectionWarnings ?? []);
         this.syncExecutionState();
         this.filterStateHash = this.buildFilterStateHash();
@@ -12891,16 +13043,40 @@ class FilterCore {
      */
     setColumns(columns) {
         this.columns = columns;
+        this.astCompiler = this.createAstCompiler();
         if (this.filterAst) {
+            if (this.executionMode === 'column' && this.filterState.length > 0) {
+                this.rebuildColumnAstNodes();
+                this.filterAst = buildFilterAstFromNodes(Array.from(this.columnAstNodes.values()), {
+                    source: 'model',
+                });
+                this.filterStateHash = this.buildFilterStateHash();
+                return;
+            }
             this.setFilterAst(this.filterAst);
             return;
         }
         if (this.filterState.length > 0) {
-            this.filterAst = buildFilterAstFromModels(this.filterState, { columns: this.columns });
-            this.syncExecutionState();
+            this.rebuildColumnAstNodes();
+            this.filterAst = buildFilterAstFromNodes(Array.from(this.columnAstNodes.values()), {
+                source: 'model',
+            });
             this.filterStateHash = this.buildFilterStateHash();
         }
     }
+    setColCount(colCount) {
+        this.colCount = colCount;
+        this.astCompiler = this.createAstCompiler();
+        if (!this.filterAst) {
+            return;
+        }
+        if (this.executionMode === 'column') {
+            this.filterStateHash = this.buildFilterStateHash();
+            return;
+        }
+        this.syncExecutionState();
+        this.filterStateHash = this.buildFilterStateHash();
+    }
     /**
      * Clear filter for a column
      * @param column - Column index
@@ -12908,7 +13084,7 @@ class FilterCore {
     clearColumnFilter(column) {
         if (this.columnFilters.has(column)) {
             this.columnFilters.delete(column);
-            this.syncStateFromColumnFilters();
+            this.removeColumnState(column);
             this.emitFilterChange();
         }
     }
@@ -12917,7 +13093,9 @@ class FilterCore {
      */
     clearAll() {
         this.columnFilters.clear();
+        this.columnAstNodes.clear();
         this.filterState = [];
+        this.refreshFilterStateSnapshot();
         this.filterStateHash = '';
         this.filterAst = null;
         this.astProjectionWarnings = [];
@@ -12933,9 +13111,12 @@ class FilterCore {
      * @returns True if row passes filter
      */
     testRow(row) {
-        if (this.executionMode === 'none' || this.executionMode === 'unexecutable') {
+        if (this.executionMode === 'none') {
             return true;
         }
+        if (this.executionMode === 'unexecutable') {
+            throw buildUnexecutableFilterError(this.astExecutionWarnings);
+        }
         if (this.executionMode === 'ast') {
             return this.compiledAstPredicate ? this.compiledAstPredicate(row) : true;
         }
@@ -12953,6 +13134,9 @@ class FilterCore {
      * @returns Array of visible row indices
      */
     getVisibleRowsBasic(rowCount) {
+        if (this.executionMode === 'unexecutable') {
+            throw buildUnexecutableFilterError(this.astExecutionWarnings);
+        }
         const visible = [];
         for (let row = 0; row < rowCount; row++) {
             if (this.testRow(row)) {
@@ -12965,7 +13149,7 @@ class FilterCore {
      * Get current legacy FilterModel state
      */
     getFilterState() {
-        return [...this.filterState];
+        return this.filterStateSnapshot;
     }
     /**
      * Get the canonical filter AST state
@@ -12995,7 +13179,7 @@ class FilterCore {
      * Check if any frontend-evaluable filters are active
      */
     hasActiveFilters() {
-        return this.executionMode === 'column' || this.executionMode === 'ast';
+        return this.executionMode !== 'none';
     }
     /**
      * Check if any canonical filters are active, even if the current frontend evaluator
@@ -13046,23 +13230,12 @@ class FilterCore {
             previousFilterState: [],
         });
     }
-    /**
-     * Rebuild legacy models and the canonical AST from column filters.
-     */
-    syncStateFromColumnFilters() {
-        this.filterState = Array.from(this.columnFilters.values()).map((filter) => filter.getModel());
-        this.filterAst = buildFilterAstFromModels(this.filterState, { columns: this.columns });
-        this.astProjectionWarnings = [];
-        this.syncExecutionState();
-        this.filterStateHash = this.buildFilterStateHash();
-        this.notifyFilterStateChange();
-    }
     createColumnFilter(column, conditions, logic) {
         return new ColumnFilter({
             column,
             conditions,
             logic,
-            onChange: () => this.syncStateFromColumnFilters(),
+            onChange: (model) => this.syncStateFromColumnModel(model),
         });
     }
     syncExecutionState() {
@@ -13076,11 +13249,7 @@ class FilterCore {
             this.executionMode = 'column';
             return;
         }
-        const compiled = new FilterAstCompiler({
-            colCount: this.colCount,
-            getValue: this.getValue,
-            columns: this.columns,
-        }).compile(this.filterAst);
+        const compiled = this.astCompiler.compile(this.filterAst);
         this.astExecutionWarnings = compiled.warnings;
         if (compiled.predicate) {
             this.compiledAstPredicate = compiled.predicate;
@@ -13090,14 +13259,7 @@ class FilterCore {
         this.executionMode = 'unexecutable';
     }
     buildFilterStateHash() {
-        if (!this.filterAst?.root && this.filterState.length === 0) {
-            return '';
-        }
-        return JSON.stringify({
-            mode: this.executionMode,
-            models: this.filterState,
-            ast: this.filterAst,
-        });
+        return buildFilterStateSignature(this.executionMode, this.filterState, this.filterAst);
     }
     assertColumnInBounds(column) {
         if (column < 0 || column >= this.colCount) {
@@ -13109,6 +13271,64 @@ class FilterCore {
             this.onFilterStateChange();
         }
     }
+    syncStateFromColumnModel(model) {
+        this.upsertFilterState(model);
+        this.upsertColumnAstNode(model);
+        this.syncColumnDerivedState();
+    }
+    removeColumnState(column) {
+        const index = this.filterState.findIndex((model) => model.column === column);
+        if (index >= 0) {
+            this.filterState.splice(index, 1);
+        }
+        this.columnAstNodes.delete(column);
+        this.syncColumnDerivedState();
+    }
+    syncColumnDerivedState() {
+        this.filterAst = buildFilterAstFromNodes(Array.from(this.columnAstNodes.values()), {
+            source: 'model',
+        });
+        this.astProjectionWarnings = [];
+        this.astExecutionWarnings = [];
+        this.compiledAstPredicate = null;
+        this.executionMode = this.filterState.length === 0 ? 'none' : 'column';
+        this.refreshFilterStateSnapshot();
+        this.filterStateHash = this.buildFilterStateHash();
+        this.notifyFilterStateChange();
+    }
+    upsertFilterState(model, target = this.filterState) {
+        const index = target.findIndex((candidate) => candidate.column === model.column);
+        if (index >= 0) {
+            target[index] = model;
+            return;
+        }
+        target.push(model);
+    }
+    upsertColumnAstNode(model) {
+        const astNode = buildFilterAstNodeFromModel(model, { columns: this.columns });
+        if (astNode) {
+            this.columnAstNodes.set(model.column, astNode);
+        }
+        else {
+            this.columnAstNodes.delete(model.column);
+        }
+    }
+    rebuildColumnAstNodes() {
+        this.columnAstNodes.clear();
+        for (const model of this.filterState) {
+            this.upsertColumnAstNode(model);
+        }
+    }
+    refreshFilterStateSnapshot() {
+        this.filterStateSnapshot = Object.freeze([...this.filterState]);
+    }
+    createAstCompiler() {
+        return new FilterAstCompiler({
+            colCount: this.colCount,
+            getValue: this.getValue,
+            columns: this.columns,
+        });
+    }
 }
 function dedupeWarnings(warnings) {
     return Array.from(new Set(warnings));
@@ -15592,12 +15812,14 @@ function inferValueType(value, valueTo) {
  * FilterQueryHandler - SQL-like query parsing and expression management.
  */
 class FilterQueryHandler {
-    constructor(core, columnNames, columns, events) {
+    constructor(core, columnNames, columns, events, getFieldFilterState, getFilterExport) {
         this.currentExpression = null;
         this.core = core;
         this.columnNames = columnNames;
         this.columns = columns;
         this.events = events;
+        this.getFieldFilterState = getFieldFilterState;
+        this.getFilterExport = getFilterExport;
         this.parser = new FilterQueryParser();
         if (this.columnNames.length > 0) {
             const columnMapping = {};
@@ -15617,16 +15839,17 @@ class FilterQueryHandler {
             return;
         }
         try {
-            const expression = this.parseFilterInput(filter);
+            const parsedExpression = this.parseFilterInput(filter);
+            this.core.setFilterAst(parsedExpression.ast ?? null);
+            const expression = this.buildCurrentExpression(parsedExpression);
             this.currentExpression = expression;
-            this.core.setFilterAst(expression.ast ?? null);
             if (this.events) {
                 this.events.emit('filter:start', {
                     timestamp: Date.now(),
                     filter: expression,
                 });
             }
-            await this.applyFrontendFilter(expression);
+            await this.applyFrontendFilter();
             if (this.events) {
                 this.events.emit('filter:end', {
                     timestamp: Date.now(),
@@ -15657,6 +15880,20 @@ class FilterQueryHandler {
             models: filter,
         };
     }
+    buildCurrentExpression(parsedExpression) {
+        const hasColumns = Array.isArray(this.columns) && this.columns.length > 0;
+        return {
+            type: parsedExpression.type,
+            ast: this.core.getFilterAst(),
+            sql: parsedExpression.sql,
+            boundSql: parsedExpression.boundSql,
+            params: parsedExpression.params,
+            models: this.core.getFilterState(),
+            quickFilter: parsedExpression.quickFilter,
+            fieldState: hasColumns ? (this.getFieldFilterState?.() ?? null) : null,
+            filterExport: hasColumns ? (this.getFilterExport?.() ?? null) : null,
+        };
+    }
     /**
      * Type guard for FilterQuery.
      */
@@ -15666,18 +15903,11 @@ class FilterQueryHandler {
     /**
      * Apply frontend filtering (in-memory).
      */
-    async applyFrontendFilter(expression) {
+    async applyFrontendFilter() {
         const projectionWarnings = this.core.getAstProjectionWarnings();
         const executionWarnings = this.core.getAstExecutionWarnings();
         if (this.core.hasUnexecutableFilters()) {
-            if (expression.type === 'sql') {
-                console.warn('Frontend SQL filtering remains compatibility-only. ' +
-                    'The canonical filter is preserved in filter.ast and filter.expression.');
-            }
-            for (const warning of executionWarnings) {
-                console.warn(`FilterQueryHandler: ${warning}`);
-            }
-            return;
+            throw buildUnexecutableFilterError(executionWarnings);
         }
         if (!this.core.isUsingAstExecution() || projectionWarnings.length === 0) {
             return;
@@ -15719,8 +15949,8 @@ class FilterQueryHandler {
 class FilterManager {
     constructor(options) {
         this.core = new FilterCore(options.colCount, options.getValue, options.columns, options.events, () => this.optimizer?.invalidateCache());
-        this.query = new FilterQueryHandler(this.core, options.columnNames || [], options.columns, options.events);
         this.exporter = new FilterExporter(this.core, options.enableExport ?? true, options.columns, options.exportConfig);
+        this.query = new FilterQueryHandler(this.core, options.columnNames || [], options.columns, options.events, () => this.exporter.getFieldFilterState(), () => this.exporter.getFilterExport());
         this.optimizer = new FilterOptimizer(this.core, options.getValue, options.enableOptimizations ?? true, {
             enableCache: options.enableCache,
             cacheCapacity: options.cacheCapacity,
@@ -15817,6 +16047,9 @@ class FilterManager {
         this.query.setColumns(columns);
         this.exporter.setColumns(columns);
     }
+    setColCount(colCount) {
+        this.core.setColCount(colCount);
+    }
     // ==================== Optimization Methods ====================
     setDataVersion(version) {
         this.optimizer.setDataVersion(version);
@@ -15864,22 +16097,23 @@ function createFilterPlugin(options) {
         name: 'filter',
         phase: 20,
         dependencies: ['core'],
-        setup(store, api) {
+        setup(store, api, context) {
             store.extend('filter.state', [], 'filter');
             store.extend('filter.ast', null, 'filter');
             store.extend('filter.quickFilter', { query: '', columns: null }, 'filter');
             store.extend('filter.expression', null, 'filter');
             store.extend('pipeline.filter', undefined, 'filter', 20);
             const usePipeline = options?.usePipeline !== false;
-            let mgr = createManager(options?.colCount ?? 0);
+            const getColumns = () => context.options.columns ?? options?.columns;
+            const getColCount = () => context.options.colCount ?? options?.colCount ?? 0;
+            let mgr = createManager(getColCount());
             // Quick filter state
             let quickFilterQuery = '';
             let quickFilterColumns = null;
             let quickFilterCache = null;
             let quickFilterCacheKey = null;
-            function getDataMode() {
-                const getMode = api.getMethod('data', 'getMode');
-                return getMode ? getMode() : 'frontend';
+            function getQueryMode() {
+                return resolveQueryExecutionMode(context.options.dataMode);
             }
             function createManager(colCount, dataAccessor) {
                 const getValue = dataAccessor
@@ -15891,7 +16125,7 @@ function createFilterPlugin(options) {
                 return new FilterManager({
                     colCount,
                     getValue,
-                    columns: options?.columns,
+                    columns: getColumns(),
                     enableExport: options?.enableExport ?? true,
                 });
             }
@@ -15906,14 +16140,15 @@ function createFilterPlugin(options) {
                 };
             }
             function buildExpression() {
-                const hasColumns = Array.isArray(options?.columns) && options.columns.length > 0;
+                const columns = getColumns();
+                const hasColumns = Array.isArray(columns) && columns.length > 0;
                 return buildModelFilterExpression({
                     models: mgr.getFilterState(),
                     quickFilter: getQuickFilterState(),
                     fieldState: hasColumns ? mgr.getFieldFilterState() : null,
                     filterExport: hasColumns ? mgr.getFilterExport() : null,
                     ast: mgr.getFilterAst(),
-                    columns: options?.columns,
+                    columns,
                 });
             }
             function persistState() {
@@ -15938,12 +16173,22 @@ function createFilterPlugin(options) {
                 if (quickFilterColumns && quickFilterColumns.length > 0) {
                     return quickFilterColumns;
                 }
-                const colCount = options?.colCount ?? 0;
-                if (options?.columns && options.columns.length > 0) {
-                    return options.columns.map((_c, index) => index);
+                const columns = getColumns();
+                const colCount = getColCount();
+                if (columns && columns.length > 0) {
+                    return columns.map((_c, index) => index);
                 }
                 return Array.from({ length: colCount }, (_, i) => i);
             }
+            const unsubscribeOptions = context.subscribeOptions((change) => {
+                if (!change.changedKeys.includes('columns') && !change.changedKeys.includes('colCount')) {
+                    return;
+                }
+                mgr.setColumns(getColumns() ?? []);
+                mgr.setColCount(getColCount());
+                clearQuickFilterCache();
+                applyFilter();
+            });
             function ensureQuickFilterCache(columns) {
                 const cacheKey = columns.join(',');
                 if (quickFilterCache && quickFilterCacheKey === cacheKey) {
@@ -15990,23 +16235,31 @@ function createFilterPlugin(options) {
                 return matches;
             }
             function applyFilter() {
-                const hasColumnFilters = mgr.hasActiveFilters();
+                const hasStructuredFilters = mgr.hasStructuredFilters();
                 const hasQuickFilter = quickFilterQuery.trim().length > 0;
                 const expression = persistState();
                 if (!usePipeline) {
                     store.set('pipeline.filter', undefined);
                     return expression;
                 }
-                if (!hasColumnFilters && !hasQuickFilter) {
+                if (!hasStructuredFilters && !hasQuickFilter) {
                     store.set('pipeline.filter', undefined);
                     warnOnStructuredProjection();
                     return expression;
                 }
+                if (mgr.hasUnexecutableFilters()) {
+                    const error = buildUnexecutableFilterError(mgr.getAstExecutionWarnings());
+                    api.fireEvent('filter:error', {
+                        timestamp: Date.now(),
+                        error,
+                    });
+                    throw error;
+                }
                 const rowCount = store.get('rows.count');
                 const input = store.getUnphased('pipeline.sort') ??
                     store.get('rows.indices');
                 let result = input;
-                if (hasColumnFilters) {
+                if (hasStructuredFilters) {
                     const visibleSet = new Set(mgr.getVisibleRows(rowCount));
                     result = result.filter((idx) => visibleSet.has(idx));
                 }
@@ -16021,7 +16274,10 @@ function createFilterPlugin(options) {
                 const prev = mgr.getFilterState();
                 mgr.setColumnFilter(col, conditions, logic);
                 applyFilter();
-                api.fireEvent('filter:change', { filterState: mgr.getFilterState(), previousFilterState: prev });
+                api.fireEvent('filter:change', {
+                    filterState: mgr.getFilterState(),
+                    previousFilterState: prev,
+                });
             }, 'filter');
             store.action('filter:clear', () => {
                 const prev = mgr.getFilterState();
@@ -16037,7 +16293,10 @@ function createFilterPlugin(options) {
                 const prev = mgr.getFilterState();
                 mgr.clearColumnFilter(col);
                 applyFilter();
-                api.fireEvent('filter:change', { filterState: mgr.getFilterState(), previousFilterState: prev });
+                api.fireEvent('filter:change', {
+                    filterState: mgr.getFilterState(),
+                    previousFilterState: prev,
+                });
             }, 'filter');
             store.action('filter:reapply', () => {
                 applyFilter();
@@ -16054,7 +16313,10 @@ function createFilterPlugin(options) {
                 quickFilterColumns = columns ?? null;
                 store.set('filter.quickFilter', { query: quickFilterQuery, columns: quickFilterColumns });
                 applyFilter();
-                api.fireEvent('filter:change', { filterState: mgr.getFilterState(), previousFilterState: prev });
+                api.fireEvent('filter:change', {
+                    filterState: mgr.getFilterState(),
+                    previousFilterState: prev,
+                });
             }, 'filter');
             store.action('filter:clearQuickFilter', () => {
                 const prev = mgr.getFilterState();
@@ -16063,7 +16325,10 @@ function createFilterPlugin(options) {
                 clearQuickFilterCache();
                 store.set('filter.quickFilter', { query: '', columns: null });
                 applyFilter();
-                api.fireEvent('filter:change', { filterState: mgr.getFilterState(), previousFilterState: prev });
+                api.fireEvent('filter:change', {
+                    filterState: mgr.getFilterState(),
+                    previousFilterState: prev,
+                });
             }, 'filter');
             store.action('filter:setState', (models) => {
                 const prev = mgr.getFilterState();
@@ -16072,13 +16337,19 @@ function createFilterPlugin(options) {
                     mgr.setColumnFilter(model.column, model.conditions, model.logic ?? 'AND');
                 }
                 applyFilter();
-                api.fireEvent('filter:change', { filterState: mgr.getFilterState(), previousFilterState: prev });
+                api.fireEvent('filter:change', {
+                    filterState: mgr.getFilterState(),
+                    previousFilterState: prev,
+                });
             }, 'filter');
             store.action('filter:setFieldState', (state) => {
                 const prev = mgr.getFilterState();
                 mgr.setFieldFilter(state);
                 applyFilter();
-                api.fireEvent('filter:change', { filterState: mgr.getFilterState(), previousFilterState: prev });
+                api.fireEvent('filter:change', {
+                    filterState: mgr.getFilterState(),
+                    previousFilterState: prev,
+                });
             }, 'filter');
             persistState();
             api.register('filter', {
@@ -16093,9 +16364,9 @@ function createFilterPlugin(options) {
                 getFilterExports: () => mgr.getFilterExport(),
                 getQuickFilter: () => store.get('filter.quickFilter'),
                 getExpression: () => store.get('filter.expression'),
-                getMode: () => getDataMode(),
+                getMode: () => getQueryMode(),
             });
-            return { teardown: [() => mgr.destroy()] };
+            return { teardown: [unsubscribeOptions, () => mgr.destroy()] };
         },
     };
 }
@@ -24178,6 +24449,37 @@ function buildQueryState(options = {}) {
     };
 }
 
+const querySignatureCache = new WeakMap();
+function getQueryStateSignature(query) {
+    if (!query) {
+        return 'version:1';
+    }
+    const cached = querySignatureCache.get(query);
+    if (cached) {
+        return cached;
+    }
+    const signature = [
+        `version:${query.version ?? 1}`,
+        `sort:${getSortSignature(query.sort)}`,
+        `filter:${getFilterAstSignature(query.filter)}`,
+        `pagination:${getPaginationSignature(query.pagination)}`,
+    ].join('|');
+    querySignatureCache.set(query, signature);
+    return signature;
+}
+function getSortSignature(sort) {
+    if (!sort || sort.length === 0) {
+        return '';
+    }
+    return stableHashValue(sort);
+}
+function getPaginationSignature(pagination) {
+    if (!pagination) {
+        return '';
+    }
+    return [pagination.page, pagination.pageSize, pagination.offset, pagination.cursor ?? ''].join(':');
+}
+
 function createAbortError(message) {
     const error = new Error(message);
     error.name = 'AbortError';
@@ -24362,7 +24664,7 @@ class DataManager extends OperationModeManager {
                 pagination: buildRangeQueryPaginationState(startRow, endRow),
             });
         // Generate cache key
-        const cacheKey = `${startRow}-${endRow}-${JSON.stringify(effectiveQuery)}`;
+        const cacheKey = `${startRow}-${endRow}-${getQueryStateSignature(effectiveQuery)}`;
         // Check cache first
         if (this.cachedRanges.has(cacheKey)) {
             const cachedData = this.cachedRanges.get(cacheKey);
@@ -24681,7 +24983,7 @@ function createDataPlugin(opts) {
         name: 'data',
         phase: 35,
         dependencies: ['core', 'dom', 'rendering'],
-        setup(store, api) {
+        setup(store, api, context) {
             const { options, state, container, events, setDataAccessor } = opts;
             const mode = resolveOperationMode({
                 mode: options.dataMode,
@@ -24726,6 +25028,9 @@ function createDataPlugin(opts) {
             function getStatus() {
                 return store.get('data.status');
             }
+            function delegatesQueryState() {
+                return shouldDelegateQueryState(context.options.dataMode);
+            }
             function setStatus(partial) {
                 store.set('data.status', {
                     ...getStatus(),
@@ -24843,15 +25148,19 @@ function createDataPlugin(opts) {
             function syncManagerData() {
                 const data = dataManager.getData();
                 const totalRows = dataManager.getTotalRows();
+                const previousTotalRows = knownTotalRows;
                 const { top, left } = state.scrollPosition;
                 knownTotalRows = totalRows;
+                context.updateOptions({ rowCount: totalRows });
                 state.data = data;
                 setDataAccessor(new ArrayAccessor(data));
                 store.exec('core:setData', data);
                 store.exec('rendering:setRowCount', totalRows);
                 store.exec('rendering:updateCanvasSize');
                 store.exec('rendering:clearCache');
-                store.exec('rendering:renderCells', top, left);
+                if (totalRows !== previousTotalRows) {
+                    store.exec('rendering:renderCells', top, left);
+                }
                 store.exec('rendering:refresh');
                 if (api.getMethod('pagination', 'update')) {
                     store.exec('pagination:update');
@@ -24923,8 +25232,12 @@ function createDataPlugin(opts) {
                 };
             }
             function buildRequest(range) {
-                const sortState = store.get('sort.state') ?? [];
-                const filterAst = store.get('filter.ast') ?? null;
+                const sortState = delegatesQueryState()
+                    ? (store.get('sort.state') ?? [])
+                    : null;
+                const filterAst = delegatesQueryState()
+                    ? (store.get('filter.ast') ?? null)
+                    : null;
                 return {
                     startRow: range.startRow,
                     endRow: range.endRow,
@@ -25049,12 +25362,12 @@ function createDataPlugin(opts) {
                 }
                 void ensureVisibleRange('scroll', payload.visibleRange);
             }), events.on('sort:change', () => {
-                if (!isRendered()) {
+                if (!isRendered() || !delegatesQueryState()) {
                     return;
                 }
                 void reloadCurrentContext('sort');
             }), events.on('filter:change', () => {
-                if (!isRendered()) {
+                if (!isRendered() || !delegatesQueryState()) {
                     return;
                 }
                 void reloadCurrentContext('filter');
@@ -26773,6 +27086,11 @@ class GridFilterUI {
         });
         this.renderFilterChips();
     }
+    setColumns(columns) {
+        this.columns = [...columns];
+        this.closePopup();
+        this.renderFilterChips();
+    }
     openFilterPopup(payload) {
         const dataCol = this.mapVisualToDataCol(payload.columnIndex);
         const columnDef = this.getColumnDef(dataCol);
@@ -26793,9 +27111,9 @@ class GridFilterUI {
         logicRow.innerHTML = `<label>Match</label>`;
         const logicSelect = document.createElement('select');
         logicSelect.className = 'zg-filter-popup__select';
-        logicSelect.innerHTML = `
-      <option value="AND">AND</option>
-      <option value="OR">OR</option>
+        logicSelect.innerHTML = `
+      <option value="AND">AND</option>
+      <option value="OR">OR</option>
     `;
         logicSelect.value = existing?.logic ?? 'AND';
         logicRow.appendChild(logicSelect);
@@ -27357,7 +27675,7 @@ function createFilterUIPlugin(options) {
         name: 'filter-ui',
         phase: 25,
         dependencies: ['filter'],
-        setup(store, api) {
+        setup(store, api, context) {
             let filterUI = null;
             store.action('filterUI:attach', (container, events) => {
                 if (filterUI) {
@@ -27366,7 +27684,7 @@ function createFilterUIPlugin(options) {
                 filterUI = new GridFilterUI({
                     container,
                     events,
-                    columns: options.columns,
+                    columns: options.getColumns(),
                     getFilterState: () => store.get('filter.state'),
                     getFilterExpression: () => store.get('filter.expression'),
                     setColumnFilter: (column, conditions, logic) => {
@@ -27397,6 +27715,12 @@ function createFilterUIPlugin(options) {
                     },
                 });
             }, 'filter-ui');
+            const unsubscribeOptions = context.subscribeOptions((change) => {
+                if (!change.changedKeys.includes('columns')) {
+                    return;
+                }
+                filterUI?.setColumns(options.getColumns() ?? []);
+            });
             api.register('filterUI', {
                 destroy: () => {
                     if (filterUI) {
@@ -27407,6 +27731,7 @@ function createFilterUIPlugin(options) {
             });
             return {
                 teardown: [
+                    unsubscribeOptions,
                     () => {
                         if (filterUI) {
                             filterUI.destroy();
@@ -27739,6 +28064,65 @@ function createLifecyclePlugin(opts) {
     };
 }
 
+class GridOptionsManager {
+    constructor(options) {
+        this.options = options;
+        this.listeners = new Set();
+    }
+    getOptions() {
+        return this.options;
+    }
+    getOptionsSnapshot() {
+        return { ...this.options };
+    }
+    update(patch) {
+        const changedKeys = Object.keys(patch).filter((key) => {
+            const optionKey = key;
+            return !Object.is(this.options[optionKey], patch[optionKey]);
+        });
+        if (changedKeys.length === 0) {
+            return null;
+        }
+        const previousOptions = this.getOptionsSnapshot();
+        const changedPatch = {};
+        const mutableOptions = this.options;
+        const mutablePatch = changedPatch;
+        for (const key of changedKeys) {
+            const value = patch[key];
+            mutableOptions[key] = value;
+            mutablePatch[key] = value;
+        }
+        const change = {
+            currentOptions: this.options,
+            previousOptions,
+            changedKeys,
+            patch: changedPatch,
+        };
+        for (const listener of this.listeners) {
+            listener(change);
+        }
+        return change;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    createPluginSetupContext() {
+        return {
+            options: this.options,
+            getOptions: () => this.getOptions(),
+            getOptionsSnapshot: () => this.getOptionsSnapshot(),
+            updateOptions: (patch) => this.update(patch),
+            subscribeOptions: (listener) => this.subscribe(listener),
+        };
+    }
+    destroy() {
+        this.listeners.clear();
+    }
+}
+
 function createSlimContext(container, options) {
     if (!container)
         throw new Error('Container element is required');
@@ -27760,13 +28144,20 @@ function createSlimContext(container, options) {
     };
     const store = new GridStoreImpl();
     const gridApi = new GridApiImpl(store, events);
-    const pluginHost = new PluginHost(store, gridApi);
+    const optionsManager = new GridOptionsManager(normalizedOptions);
+    const pluginHost = new PluginHost(store, gridApi, optionsManager.createPluginSetupContext());
     const pipelineRegistry = new PipelineRegistry();
     pipelineRegistry.registerPhase('sort', 10, 'pipeline.sort');
     pipelineRegistry.registerPhase('filter', 20, 'pipeline.filter');
+    gridApi.register('options', {
+        get: () => optionsManager.getOptions(),
+        getSnapshot: () => optionsManager.getOptionsSnapshot(),
+        subscribe: (listener) => optionsManager.subscribe(listener),
+    });
     return {
         container,
         options: normalizedOptions,
+        optionsManager,
         state,
         events,
         store,
@@ -27778,12 +28169,6 @@ function createSlimContext(container, options) {
 }
 function installAllPlugins(ctx) {
     const { options, events, pluginHost, store } = ctx;
-    const resolvedDataMode = resolveOperationMode({
-        mode: options.dataMode,
-        callback: options.onDataRequest,
-    }, {
-        rowCount: options.rowCount,
-    });
     // Phase 0: Core
     pluginHost.use(createCorePlugin());
     // Phase 5: DOM
@@ -27792,13 +28177,13 @@ function installAllPlugins(ctx) {
     pluginHost.use(createSortPlugin({
         enableMultiSort: true,
         columns: options.columns,
-        usePipeline: resolvedDataMode !== 'backend',
+        usePipeline: resolveQueryExecutionMode(options.dataMode) !== 'backend',
     }));
     // Phase 20: Filter
     pluginHost.use(createFilterPlugin({
         colCount: options.colCount,
         columns: options.columns,
-        usePipeline: resolvedDataMode !== 'backend',
+        usePipeline: resolveQueryExecutionMode(options.dataMode) !== 'backend',
     }));
     // Phase 30: Rendering
     let columnModel = null;
@@ -27818,7 +28203,9 @@ function installAllPlugins(ctx) {
         state: ctx.state,
         container: ctx.container,
         events,
-        setDataAccessor: (da) => { dataAccessor = da; },
+        setDataAccessor: (da) => {
+            dataAccessor = da;
+        },
     }));
     // Phase 40: Selection
     if (options.enableSelection !== false) {
@@ -27865,14 +28252,22 @@ function installAllPlugins(ctx) {
         container: ctx.container,
         events,
         getDataAccessor: () => dataAccessor,
-        setColumnModel: (cm) => { columnModel = cm; },
+        setColumnModel: (cm) => {
+            columnModel = cm;
+        },
     }));
     // Setup pipeline computeds
     ctx.pipelineRegistry.setupCoreComputeds(store);
     // Expose closures for late-binding references
-    ctx._setColumnModel = (cm) => { columnModel = cm; };
-    ctx._setDataAccessor = (da) => { dataAccessor = da; };
-    ctx._setSelectionChecker = (sc) => { selectionChecker = sc; };
+    ctx._setColumnModel = (cm) => {
+        columnModel = cm;
+    };
+    ctx._setDataAccessor = (da) => {
+        dataAccessor = da;
+    };
+    ctx._setSelectionChecker = (sc) => {
+        selectionChecker = sc;
+    };
     ctx._getColumnModel = () => columnModel;
     ctx._getDataAccessor = () => dataAccessor;
     // Wire selection checker updates from lifecycle plugin
@@ -27880,9 +28275,12 @@ function installAllPlugins(ctx) {
         selectionChecker = checker;
     });
     // Install filter UI if columns + filter are present
-    if (options.columns && options.columns.length > 0 && pluginHost.has('filter') && !pluginHost.has('filter-ui')) {
+    if (options.columns &&
+        options.columns.length > 0 &&
+        pluginHost.has('filter') &&
+        !pluginHost.has('filter-ui')) {
         pluginHost.use(createFilterUIPlugin({
-            columns: options.columns,
+            getColumns: () => options.columns,
             getColumnDef: (dataCol) => options.columns?.[dataCol],
             getColumnModel: () => columnModel,
             getContainer: () => ctx.container,
@@ -27916,7 +28314,12 @@ function installAllPlugins(ctx) {
             },
             getDOM: () => {
                 const domApi = ctx.gridApi.getMethod('dom', 'getCanvas');
-                return domApi ? { canvas: domApi(), updateCanvasSize: (w, h) => store.exec('dom:updateCanvasSize', w, h) } : null;
+                return domApi
+                    ? {
+                        canvas: domApi(),
+                        updateCanvasSize: (w, h) => store.exec('dom:updateCanvasSize', w, h),
+                    }
+                    : null;
             },
             setData: (data) => {
                 store.exec('core:setData', data);
@@ -27926,7 +28329,7 @@ function installAllPlugins(ctx) {
             },
             getState: () => ({ data: ctx.state.data, rowCount: options.rowCount }),
             setRowCount: (count) => {
-                options.rowCount = count;
+                ctx.optionsManager.update({ rowCount: count });
             },
         }));
     }
@@ -28758,10 +29161,7 @@ function createSortApi(ctx) {
             const getMode = ctx.gridApi.getMethod('sort', 'getMode');
             if (getMode)
                 return getMode();
-            const mode = ctx.options.dataMode ?? 'frontend';
-            if (mode === 'auto')
-                return ctx.options.onDataRequest ? 'backend' : 'frontend';
-            return mode;
+            return resolveQueryExecutionMode(ctx.options.dataMode);
         },
     };
 }
@@ -28830,10 +29230,7 @@ function createFilterApi(ctx) {
             const api = ctx.gridApi.getMethod('filter', 'getMode');
             if (api)
                 return api();
-            const mode = ctx.options.dataMode ?? 'frontend';
-            if (mode === 'auto')
-                return ctx.options.onDataRequest ? 'backend' : 'frontend';
-            return mode;
+            return resolveQueryExecutionMode(ctx.options.dataMode);
         },
         setQuick(query, columns) {
             if (!hasFilterPlugin())
@@ -29243,7 +29640,7 @@ class Grid {
     setData(data) {
         this.ctx.store.exec('core:setData', data);
         this.ctx.state.data = data;
-        this.ctx.options.rowCount = data.length;
+        this.ctx.optionsManager.update({ rowCount: data.length });
         const dataAccessor = new ArrayAccessor(data);
         this.ctx._setDataAccessor?.(dataAccessor);
         if (this.ctx.pluginHost.has('infinite-scroll'))
@@ -29311,7 +29708,8 @@ class Grid {
         if (this.ctx.isDestroyed)
             return;
         this._theme.destroyAutoTheme();
-        this.ctx.pluginHost.destroy();
+        this.ctx.pluginHost?.destroy?.();
+        this.ctx.optionsManager?.destroy?.();
         this.ctx.container.innerHTML = '';
         this.ctx.container.classList.remove('zg-grid');
         this.ctx.state.data = [];
@@ -29323,7 +29721,9 @@ class Grid {
         this.ctx.store.exec('rendering:registerRenderer', name, renderer);
     }
     updateOptions(options) {
-        Object.assign(this.ctx.options, options);
+        const change = this.ctx.optionsManager.update(options);
+        if (!change)
+            return;
         this.ctx.store.exec('rendering:updateScroller');
         this.ctx.store.exec('rendering:refresh');
     }
@@ -29360,7 +29760,12 @@ class Grid {
     getSlidingWindowStats() {
         if (this.ctx.pluginHost.has('infinite-scroll'))
             return this.ctx.store.get('infiniteScroll.stats');
-        return { virtualOffset: 0, rowsInMemory: this.ctx.state.data.length, totalRowsLoaded: 0, prunedRows: 0 };
+        return {
+            virtualOffset: 0,
+            rowsInMemory: this.ctx.state.data.length,
+            totalRowsLoaded: 0,
+            prunedRows: 0,
+        };
     }
     // --- Theme ---
     setTheme(nameOrObject) {