@genesislcap/grid-pro 15.30.0 → 15.30.2

package/dist/esm/datasource/base.datasource.js

@@ -1,5 +1,6 @@
 import { __awaiter, __decorate } from "tslib";
 import { Connect, Datasource, DatasourceDefaults, DatasourceEventHandler, FieldTypeEnum, logger, normaliseCriteria, ResourceType, } from '@genesislcap/foundation-comms';
+import { JSONSerializer } from '@genesislcap/foundation-utils';
 import { attr, nullableNumberConverter, observable, volatile } from '@microsoft/fast-element';
 import { FoundationElement } from '@microsoft/fast-foundation';
 import { BehaviorSubject } from 'rxjs';
@@ -141,11 +142,23 @@ export class GenesisGridDatasourceElement extends DatasourceEventHandler(Foundat
             requestAutoSetup: this.requestAutoSetup,
         };
     }
+    /**
+     * The criteria the resource should be read with: the `criteria` attribute plus anything added
+     * through `setFilter()`.
+     * @internal
+     */
     buildCriteria() {
-        var _a;
-        const initialCriteria = ((_a = this.criteria) === null || _a === void 0 ? void 0 : _a.split(criteriaDelimiter)) || [];
-        const criteria = initialCriteria.concat(Array.from(this.criteriaFromFilters.values()));
-        const normalisedCriteria = normaliseCriteria(criteria.join(criteriaJoin), criteriaDelimiter);
+        var _a, _b;
+        // Blank fragments are dropped before joining. `criteria` is often bound to an empty string
+        // rather than left unset, and ''.split(';') is [''], so without this a single setFilter()
+        // produced " && FIELD == 'x'" - a leading operator the server rejects as invalid Groovy.
+        const parts = [
+            ...((_b = (_a = this.criteria) === null || _a === void 0 ? void 0 : _a.split(criteriaDelimiter)) !== null && _b !== void 0 ? _b : []),
+            ...this.criteriaFromFilters.values(),
+        ]
+            .map((part) => part === null || part === void 0 ? void 0 : part.trim())
+            .filter(Boolean);
+        const normalisedCriteria = normaliseCriteria(parts.join(criteriaJoin), criteriaDelimiter);
         return normalisedCriteria ? normalisedCriteria : undefined;
     }
     setFilter(fieldName, newFilter) {
@@ -360,11 +373,9 @@ export class GridProBaseDatasource extends GenesisGridDatasourceElement {
         this.dataSubWasLoggedOff = false;
         this.keepColDefsOnClearRowData = false;
         this.rowData = new Map();
-        this.transactionData = {
-            add: [],
-            remove: [],
-            update: [],
-        };
+        this.transactionData = { add: [], remove: [], update: [] };
+        /** So rows without a row id are warned about once per element, not once per block. @internal */
+        this.missingRowIdWarned = false;
         this._isDisconnected = false;
     }
     subscribeToConnection() {
@@ -467,32 +478,60 @@ export class GridProBaseDatasource extends GenesisGridDatasourceElement {
             }
         });
     }
+    /**
+     * Resolves the id of the held row a stream row refers to.
+     * @remarks Under a custom `row-id` a DATASERVER push may carry only the default id
+     * (`ROW_REF`), so the held row with that default id supplies the custom one. Returns
+     * `undefined` when neither id is present - callers skip the row rather than matching
+     * `undefined === undefined` against the first held row.
+     * @internal
+     */
+    resolveRowId(row) {
+        const rowId = row === null || row === void 0 ? void 0 : row[this.rowId];
+        if (rowId !== undefined && rowId !== null) {
+            return rowId;
+        }
+        if (this.hasDefaultRowId || this.isRequestServer) {
+            return undefined;
+        }
+        const defaultRowId = this.defaultRowIdByResourceType;
+        const defaultKey = row === null || row === void 0 ? void 0 : row[defaultRowId];
+        if (defaultKey === undefined || defaultKey === null) {
+            return undefined;
+        }
+        for (const held of this.rowData.values()) {
+            if ((held === null || held === void 0 ? void 0 : held[defaultRowId]) === defaultKey) {
+                return held[this.rowId];
+            }
+        }
+        return undefined;
+    }
     handleStreamDeletes(deletedRows) {
         deletedRows === null || deletedRows === void 0 ? void 0 : deletedRows.forEach((deleteData) => {
-            if (this.hasDefaultRowId || this.isRequestServer) {
-                this.transactionData.remove.push({ [this.rowId]: deleteData[this.rowId] });
-            }
-            else {
-                const rowToBeDeleted = Object.values(Object.fromEntries(this.rowData)).find((obj) => obj[this.defaultRowIdByResourceType] === deleteData[this.defaultRowIdByResourceType]);
-                this.transactionData.remove.push({ [this.rowId]: rowToBeDeleted[this.rowId] });
+            const rowId = this.resolveRowId(deleteData);
+            if (rowId === undefined) {
+                logger.warn('Attempted to delete row without a resolvable rowId', deleteData);
+                return;
             }
-            this.rowData.delete(deleteData[this.rowId]);
+            this.transactionData.remove.push({ [this.rowId]: rowId });
+            this.rowData.delete(rowId);
         });
     }
     handleStreamUpdates(updatedRows) {
         updatedRows === null || updatedRows === void 0 ? void 0 : updatedRows.forEach((updateData) => {
-            let updatedRow;
-            if (this.hasDefaultRowId || this.isRequestServer) {
-                const rowToBeUpdated = this.rowData.get(updateData[this.rowId]);
-                updatedRow = Object.assign(Object.assign({}, rowToBeUpdated), updateData);
-                this.transactionData.update.push(updatedRow);
-            }
-            else {
-                const rowToBeUpdated = Object.values(Object.fromEntries(this.rowData)).find((obj) => obj[this.defaultRowIdByResourceType] === updateData[this.defaultRowIdByResourceType]);
-                updatedRow = Object.assign(Object.assign({}, rowToBeUpdated), updateData);
-                this.transactionData.update.push(updatedRow);
+            const rowId = this.resolveRowId(updateData);
+            const rowToBeUpdated = rowId === undefined ? undefined : this.rowData.get(rowId);
+            if (!rowToBeUpdated) {
+                // Neither the grid nor consumers hold the row, so there is nothing to update; the row is
+                // reported as `add` if and when a block delivers it.
+                logger.debug('Ignoring update for a row that is not held', updateData);
+                return;
             }
-            this.rowData.set(updateData[this.rowId], updatedRow);
+            // A partial MODIFY resolved through the default id carries the custom id as undefined;
+            // keep the resolved one.
+            const updatedRow = Object.assign(Object.assign(Object.assign({}, rowToBeUpdated), updateData), { [this.rowId]: rowId });
+            this.transactionData.update.push(updatedRow);
+            this.rowData.set(rowId, updatedRow);
         });
     }
     applyAllTransactions() {
@@ -525,6 +564,119 @@ export class GridProBaseDatasource extends GenesisGridDatasourceElement {
             changes: mappedTransaction,
         });
     }
+    /**
+     * Reports rows a block-based row model (server-side, infinite) has just handed to the grid.
+     * Rows not held before are reported as `add`; rows already held (a block re-read after a
+     * refresh, or a req/rep re-read after a commit or poll) are reported as `update` only when
+     * their content changed, so a plain re-read is silent.
+     * @remarks `rowData` holds the rows delivered since the last cache reset: the resource reports
+     * rows a re-read no longer returned (`reportWithdrawnRows`), and `clearRowData` empties it when
+     * the grid drops its cache. Block eviction is not mirrored - see `DeliveredBlockLedger` - so
+     * this is a superset of what the grid holds.
+     * @internal
+     */
+    reportDeliveredRows(rows) {
+        const transaction = this.resetTransaction();
+        rows.forEach((row) => {
+            const rowId = row === null || row === void 0 ? void 0 : row[this.rowId];
+            if (rowId === undefined || rowId === null) {
+                this.warnMissingRowIdOnce(row);
+                return;
+            }
+            const known = this.rowData.get(rowId);
+            if (!known) {
+                transaction.add.push(row);
+            }
+            else if (this.hasRowContentChanged(known, row)) {
+                transaction.update.push(row);
+            }
+            this.rowData.set(rowId, row);
+        });
+        this.emitTransaction(transaction);
+    }
+    /**
+     * Reports rows a block re-read no longer returned: they left the grid (deleted on the server,
+     * or moved into a block that reports them again). Rows already reported removed - a DATASERVER
+     * push, say - are skipped.
+     * @internal
+     */
+    reportWithdrawnRows(rowIds) {
+        const transaction = this.resetTransaction();
+        rowIds.forEach((rowId) => {
+            if (!this.rowData.has(rowId)) {
+                return;
+            }
+            this.rowData.delete(rowId);
+            transaction.remove.push({ [this.rowId]: rowId });
+        });
+        this.emitTransaction(transaction);
+    }
+    /**
+     * Starts a fresh transaction and returns it, so a caller can keep working on the object it
+     * built even if a consumer's `datasource-data-changed` handler resets the element meanwhile.
+     * @internal
+     */
+    resetTransaction() {
+        const transaction = { add: [], remove: [], update: [] };
+        this.transactionData = transaction;
+        return transaction;
+    }
+    /**
+     * Whether two versions of a row differ in content. Identity and a key-order-insensitive
+     * field comparison come first, so a re-read of unchanged rows costs no serialization; nested
+     * values fall back to the serializer.
+     * @internal
+     */
+    hasRowContentChanged(known, row) {
+        if (known === row) {
+            return false;
+        }
+        if (!known || !row || typeof known !== 'object' || typeof row !== 'object') {
+            return true;
+        }
+        const knownKeys = Object.keys(known);
+        const rowKeys = Object.keys(row);
+        if (knownKeys.length !== rowKeys.length) {
+            return true;
+        }
+        for (const key of rowKeys) {
+            const before = known[key];
+            const after = row[key];
+            if (before === after) {
+                continue;
+            }
+            if (before !== null &&
+                after !== null &&
+                typeof before === 'object' &&
+                typeof after === 'object' &&
+                this.serializer.serialize(before) === this.serializer.serialize(after)) {
+                continue;
+            }
+            return true;
+        }
+        return false;
+    }
+    /** Emits `datasource-data-changed` for `transaction` when it is non-empty. @internal */
+    emitTransaction(transaction) {
+        if (!transaction) {
+            return;
+        }
+        const { add, update, remove } = transaction;
+        if (!(add === null || add === void 0 ? void 0 : add.length) && !(update === null || update === void 0 ? void 0 : update.length) && !(remove === null || remove === void 0 ? void 0 : remove.length)) {
+            return;
+        }
+        this.$emit(datasourceEventNames.dataChanged, {
+            changes: transaction,
+        });
+    }
+    /** @internal */
+    warnMissingRowIdOnce(row) {
+        if (this.missingRowIdWarned) {
+            return;
+        }
+        this.missingRowIdWarned = true;
+        logger.warn(`Rows delivered by ${this.resourceName} carry no '${this.rowId}' value and are not reported in datasource-data-changed; set row-id to the field that identifies them.`, row);
+    }
     /**
      * Builds the index map used for server-side sorting from the resource's metadata.
      * @remarks Real DATASERVER indexes keep their names; when the resource also (or only) reports
@@ -707,3 +859,6 @@ export class GridProBaseDatasource extends GenesisGridDatasourceElement {
         return additionalPanels;
     }
 }
+__decorate([
+    JSONSerializer
+], GridProBaseDatasource.prototype, "serializer", void 0);

package/dist/esm/datasource/dataserver-result.filter.js

@@ -0,0 +1,28 @@
+import { DatasourceDefaults, dataServerResultFilter, } from '@genesislcap/foundation-comms';
+/**
+ * Filters a DATASERVER batch into inserts/updates/deletes, keeping the default row id
+ * (`ROW_REF`) on every row alongside the configured one.
+ * @remarks `dataServerResultFilter` resolves the configured `rowId` out of `DETAILS` and then
+ * drops `DETAILS` entirely. Under a custom `row-id` that loses the only id a pushed MODIFY or
+ * DELETE carries: Genesis sends those as `DETAILS: { OPERATION, ROW_REF }` plus the changed
+ * fields, so the custom id is absent and the row arrives with no resolvable identity at all.
+ * Hoisting `ROW_REF` before the filter runs keeps it on both the rows a block delivers and the
+ * rows a push carries, which is what lets `resolveRowId` match one to the other.
+ *
+ * Columns come from the resource's field metadata, not from row keys, so the extra field does
+ * not add a column.
+ * @internal
+ */
+export function filterDataserverResult(result, rowId) {
+    var _a;
+    const defaultRowId = DatasourceDefaults.DATASERVER_ROW_ID;
+    if (rowId === defaultRowId) {
+        return dataServerResultFilter(result, rowId);
+    }
+    const withRowRef = Object.assign(Object.assign({}, result), { ROW: (_a = result.ROW) === null || _a === void 0 ? void 0 : _a.map((row) => {
+            var _a, _b;
+            const rowRef = (_b = (_a = row === null || row === void 0 ? void 0 : row.DETAILS) === null || _a === void 0 ? void 0 : _a[defaultRowId]) !== null && _b !== void 0 ? _b : row === null || row === void 0 ? void 0 : row[defaultRowId];
+            return rowRef === undefined || rowRef === null ? row : Object.assign(Object.assign({}, row), { [defaultRowId]: rowRef });
+        }) });
+    return dataServerResultFilter(withRowRef, rowId);
+}

package/dist/esm/datasource/delivered-block.ledger.js

@@ -0,0 +1,52 @@
+/**
+ * Tracks which row ids each block has handed to AG Grid, so the host can learn when a re-read of
+ * a block no longer returns a row (it left the grid).
+ * @remarks Plain class shared by the infinite and SSRM resources - AG Grid does not report that
+ * event.
+ *
+ * Block eviction is deliberately **not** mirrored here. AG Grid evicts by last access
+ * (`InfiniteCache.purgeBlocksIfNeeded` sorts on `lastAccessed` and never evicts a displayed or
+ * focused block; the SSRM `LazyCache` purges by distance from the viewport), and a datasource is
+ * told about neither the accesses nor the evictions. Any eviction model built from delivery order
+ * alone diverges from the grid's as soon as the user scrolls back, which would drop a visible
+ * row from the held set and silence the pushes that follow. So the held set means "rows delivered
+ * since the last cache reset": a superset of what the grid holds, which keeps every push for a
+ * possibly-visible row flowing and costs only a re-delivered row being reported as unchanged
+ * rather than as an `add`.
+ * @internal
+ */
+export class DeliveredBlockLedger {
+    constructor(rowId) {
+        this.rowId = rowId;
+        /** Row ids per block start row. */
+        this.blocks = new Map();
+    }
+    /** Records the rows handed to the grid for the block at `startRow`. */
+    record(startRow, rows) {
+        const ids = new Set();
+        rows.forEach((row) => {
+            const id = row === null || row === void 0 ? void 0 : row[this.rowId];
+            if (id !== undefined && id !== null) {
+                ids.add(id);
+            }
+        });
+        const previous = this.blocks.get(startRow);
+        this.blocks.set(startRow, ids);
+        const withdrawnRowIds = previous
+            ? [...previous].filter((id) => !ids.has(id) && !this.isHeld(id))
+            : [];
+        return { withdrawnRowIds };
+    }
+    /** Forgets every block, for when the grid drops its whole cache (filter/sort change, destroy). */
+    clear() {
+        this.blocks.clear();
+    }
+    isHeld(id) {
+        for (const ids of this.blocks.values()) {
+            if (ids.has(id)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/esm/datasource/infinite.datasource.js

@@ -2,6 +2,7 @@ import { __awaiter, __decorate } from "tslib";
 import { Connect, ConnectEvents, Datasource, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
 import { LifecycleMixin } from '@genesislcap/foundation-utils';
 import { customElement, DOM, observable } from '@microsoft/fast-element';
+import { debounceTime, skip } from 'rxjs/operators';
 import { gridProGenesisDatasourceEventNames } from '../grid-pro-genesis-datasource';
 import { datasourceEventNames, } from '../grid-pro-genesis-datasource/datasource-events.types';
 import { logger } from '../utils';
@@ -9,6 +10,8 @@ import { GridProBaseDatasource } from './base.datasource';
 import { GenesisInfiniteDatasource } from './infinite.resource';
 import { getFilterByFieldType, getServerSideFilterParamsByFieldType, } from './server-side.grid-definitions';
 const criteriaDelimiter = ';';
+/** How long a burst of `setFilter()` calls is collapsed for, matching the client-side model. */
+const FILTER_DEBOUNCE_MS = 600;
 /**
  * A Genesis Datasource element for AG Grid's Infinite Row Model.
  * @remarks
@@ -40,12 +43,15 @@ const criteriaDelimiter = ';';
  * @fires datasource-initialize - Fired to hand off infinite row model grid options. detail: `InitializeEventDetail`
  * @fires datasource-init - Fired when the infinite grid model should initialize data
  * @fires datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`
+ * @fires datasource-data-changed - Fired when rows are delivered to the grid, a DATASERVER push changes them, or a re-read no longer returns them; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`
  * @fires set-infinite-datasource - Fired to attach or clear the infinite row model datasource. detail: `SetInfiniteDatasourceEventDetail`
  * @fires refresh-infinite-cache - Fired to request an infinite row model refresh; `purge` drops the block cache and re-reads. detail: `RefreshInfiniteCacheEventDetail`
  * @fires add-grid-css-class - Fired to add a CSS class on the grid host (hover sort indicators). detail: `GridCssClassEventDetail`
  * @fires remove-grid-css-class - Fired to remove that CSS class from the grid host. detail: `GridCssClassEventDetail`
  * @fires cache-filter-config - Fired to persist filter configuration for the grid
- * @fires datasource-data-cleared - Fired when infinite row data is cleared. detail: `DataClearedEventDetail`
+ * @fires datasource-data-cleared - Fired when the grid drops every row it held (reload, filter or sort change, destroy); `includeSchema` says whether the columns went too. detail: `DataClearedEventDetail`
+ * @fires datasource-loading-finished - Fired when the first block comes back with rows
+ * @fires datasource-no-data-available - Fired when the first block comes back empty
  * @fires datasource-filters-restored - Fired when persisted filters are reapplied
  */
 let GridProInfiniteDatasource = class GridProInfiniteDatasource extends LifecycleMixin(GridProBaseDatasource) {
@@ -61,6 +67,10 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 this.setDisconnected(true);
                 return;
             }
+            if (!this.isInfiniteSupportedForResource()) {
+                this.clearRowData();
+                return;
+            }
             this.$emit(gridProGenesisDatasourceEventNames.dataInit);
             this.setDisconnected(false);
             this.indexes = this.getResourceIndexes(this.datasource.availableIndexes, this.datasource.availableSortableFields);
@@ -78,15 +88,14 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 // VIEW_NUMBER 0 means "pagination disabled": the server continues from the cursor it
                 // holds on the last row it delivered, rather than re-seeking by offset.
                 getMoreRowsFunc: (sourceRef) => this.connect.getMoreRows(sourceRef, 0),
-                // A pushed INSERT/DELETE changes which rows exist or their order, so the rows are
-                // re-read (purge); a pushed MODIFY is already patched into the cache, so the grid only
-                // needs to re-render its blocks.
-                onRowsInvalidatedFunc: () => this.$emit(datasourceEventNames.refreshInfiniteCache, {
-                    purge: true,
-                }),
-                onRowsUpdatedFunc: () => this.$emit(datasourceEventNames.refreshInfiniteCache, {
-                    purge: false,
-                }),
+                onRowsDeliveredFunc: this.reportDeliveredRows.bind(this),
+                onRowsWithdrawnFunc: this.reportWithdrawnRows.bind(this),
+                // A filter or sort change drops every block: forget the rows and tell consumers.
+                onRowCacheResetFunc: () => this.clearRowData(false),
+                onRowsInvalidatedFunc: this.handleLiveRowsInvalidated.bind(this),
+                onRowsUpdatedFunc: this.handleLiveRowsUpdated.bind(this),
+                onNoDataAvailableFunc: () => this.$emit(datasourceEventNames.noDataAvailable),
+                onDataAvailableFunc: () => this.$emit(datasourceEventNames.loadingFinished),
                 errorHandlerFunc: this.handleErrors.bind(this),
                 resourceName: this.resourceName,
                 resourceParams: this.isRequestServer
@@ -96,8 +105,12 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 resourceColDefs: this.datasource.originalFieldDef,
                 maxRows: +this.maxRows,
                 rowId: this.rowId,
-                baseCriteria: this.criteria,
+                // The merged criteria, so a criteria added through setFilter() is read with the rows
+                // rather than dropped: the logon builder replaces CRITERIA_MATCH with what it is given.
+                baseCriteria: this.buildCriteria(),
                 isRequestServer: this.isRequestServer,
+                defaultOrderBy: this.orderBy,
+                defaultReverse: this.reverse,
             });
             // Emit event to set infinite datasource
             this.$emit(datasourceEventNames.setInfiniteDatasource, {
@@ -140,6 +153,7 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 return;
             this.init();
             this.subscribeToConnection();
+            this.subscribeToFilterChanges();
         });
     }
     disconnectedCallback() {
@@ -150,8 +164,34 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
                 return;
             yield this.destroy();
             this.unsubscribeFromConnection();
+            this.unsubscribeFromFilterChanges();
         }));
     }
+    /**
+     * Reloads when `setFilter()` or `removeFilter()` changes the criteria.
+     * @remarks The criteria a block is read with is captured when the resource is built, so a
+     * filter added later reaches nothing until the rows are re-read. The `criteria` attribute
+     * already reloads through `criteriaChanged`; this gives the programmatic API the same
+     * behaviour instead of silently doing nothing.
+     * @internal
+     */
+    subscribeToFilterChanges() {
+        this.unsubscribeFromFilterChanges();
+        // Same shape as the client-side datasource: `update` is a BehaviorSubject, so skip(1) drops
+        // the value it replays on subscribe (the state init() is already reading), and the debounce
+        // collapses a burst of setFilter calls into one reload.
+        this.filterSub = this.update.pipe(skip(1), debounceTime(FILTER_DEBOUNCE_MS)).subscribe(() => {
+            if (!this.infiniteDatasource)
+                return;
+            this.reloadResourceData();
+        });
+    }
+    /** @internal */
+    unsubscribeFromFilterChanges() {
+        var _a;
+        (_a = this.filterSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.filterSub = undefined;
+    }
     deepClone() {
         const copy = super.deepClone();
         copy.deferredGridOptions = structuredClone(this.deferredGridOptions);
@@ -169,7 +209,10 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
             // The paging DATA_LOGON is opened through connect.stream, not this.datasource, so destroying
             // the comms datasource below does not close it. Dispose the IDatasource explicitly or every
             // criteria change (e.g. a bound search box) leaks a live subscription and its block timers.
-            (_b = (_a = this.infiniteDatasource) === null || _a === void 0 ? void 0 : _a.destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+            // detach(), not destroy(): AG Grid keeps calling this bean until the replacement is attached
+            // a round trip later, and the purge below re-requests blocks immediately. destroy() alone
+            // would leave it reading with the old criteria and reporting those rows as delivered.
+            (_b = (_a = this.infiniteDatasource) === null || _a === void 0 ? void 0 : _a.detach) === null || _b === void 0 ? void 0 : _b.call(_a);
             this.infiniteDatasource = undefined;
             this.datasource.destroy();
             // Emit event to cache current filter model before clearing data
@@ -225,6 +268,69 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
     clearReadyListener() {
         this.removeEventListener(datasourceEventNames.ready, this.onDatasourceReady);
     }
+    /**
+     * Whether the infinite row model can drive this resource.
+     * @remarks It pages a req/rep by sending CRITERIA_MATCH, ORDER_BY and OFFSET in DETAILS, which
+     * a request reply only accepts when it is declared `criteriaOnlyRequest`
+     * (`CRITERIA_ONLY_REQUEST` in its metadata). Without it the server expects its inputs in
+     * `REQUEST` instead and rejects every block, which on this row model surfaces as a grid that
+     * simply never fills. Report it once, up front, as the server-side model does.
+     * @returns `true` when the infinite model can be used, `false` after reporting a
+     * `resource-type` error.
+     * @internal
+     */
+    isInfiniteSupportedForResource() {
+        if (!this.isRequestServer || this.datasource.criteriaOnlyRequest) {
+            return true;
+        }
+        this.handleErrors(`Infinite row model is not supported for the REQUEST_SERVER resource '${this.resourceName}' because it does not support criteria-only requests. Set 'criteriaOnlyRequest = true' on the request reply definition, or use a client-side datasource for this resource.`, 'resource-type');
+        return false;
+    }
+    /**
+     * A pushed INSERT/DELETE changes which rows exist or their order, so the change is reported
+     * and then the rows are re-read (purge).
+     * @internal
+     */
+    handleLiveRowsInvalidated(change) {
+        this.reportLiveChange(change);
+        this.$emit(datasourceEventNames.refreshInfiniteCache, {
+            purge: true,
+        });
+    }
+    /**
+     * A pushed MODIFY is already patched into the paging cache, so the change is reported and the
+     * grid only needs to re-render its blocks.
+     * @internal
+     */
+    handleLiveRowsUpdated(change) {
+        this.reportLiveChange(change);
+        this.$emit(datasourceEventNames.refreshInfiniteCache, {
+            purge: false,
+        });
+    }
+    /**
+     * Turns a DATASERVER push into the same transaction the client-side datasource reports:
+     * partial MODIFY rows are merged into the held row, and a remove carries just the row id.
+     * @remarks Unlike the client-side model, a pushed row need not be held here - it may sit
+     * beyond the loaded blocks, in which case the grid will never show it.
+     *
+     * So a pushed INSERT is deliberately not reported: nothing here says where the new row sorts,
+     * and reporting an `add` for a row that lands at position 40,000 of an unscrolled grid would
+     * contradict the event's contract and leave the row held forever, since no block re-read ever
+     * delivers (or withdraws) it. Every INSERT is followed by a purge and re-read, which reports
+     * the row as `add` if and when it actually reaches the grid.
+     *
+     * A MODIFY for a row that is not held is skipped for the same reason; a DELETE is reported by
+     * the id it carries, and one that cannot be resolved to an id is skipped with a warning rather
+     * than matched against the wrong row.
+     * @internal
+     */
+    reportLiveChange(change) {
+        const transaction = this.resetTransaction();
+        this.handleStreamUpdates(change.updates);
+        this.handleStreamDeletes(change.deletes);
+        this.emitTransaction(transaction);
+    }
     destroy() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
@@ -237,7 +343,9 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
             this.datasource.destroy();
             this.clearRowData();
             if (this.infiniteDatasource) {
-                (_b = (_a = this.infiniteDatasource).destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+                // The host is done with this bean for good, so detach rather than destroy - see
+                // reloadResourceData.
+                (_b = (_a = this.infiniteDatasource).detach) === null || _b === void 0 ? void 0 : _b.call(_a);
                 this.infiniteDatasource = undefined;
             }
             // Emit events instead of direct grid access
@@ -252,15 +360,18 @@ let GridProInfiniteDatasource = class GridProInfiniteDatasource extends Lifecycl
             yield this.init();
         });
     }
+    /**
+     * Forgets every held row and tells consumers, as the client-side datasource does: the grid is
+     * dropping its rows (a reload, a filter or sort change, or teardown). `withColumnDefs` also
+     * clears the column definitions.
+     * @internal
+     */
     clearRowData(withColumnDefs = true) {
         this.rowData = new Map();
-        if (withColumnDefs) {
-            // Emit event to clear column definitions
-            this.$emit(datasourceEventNames.dataCleared, {
-                includeSchema: true,
-            });
-        }
-        this.transactionData = { remove: [] };
+        this.resetTransaction();
+        this.$emit(datasourceEventNames.dataCleared, {
+            includeSchema: withColumnDefs,
+        });
     }
     /**
      * Honours `pollTriggerEvents` without polling: a commit ACK for one of the listed events