@genesislcap/grid-pro 15.50.0 → 15.50.2

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

@@ -1,7 +1,7 @@
 import { __awaiter } from "tslib";
-import { MessageType, } from '@genesislcap/foundation-comms';
+import { dataserverPagingStatus, describeDataserverPagingStop, MessageType, resolveMaxView, } from '@genesislcap/foundation-comms';
 import { logger } from '../utils';
-import { filterDataserverResult } from './dataserver-result.filter';
+import { cachedRowKeyResolver, filterDataserverResult } from './dataserver-result.filter';
 import { DeliveredBlockLedger } from './delivered-block.ledger';
 import { convertFilterModelToCriteria } from './filter.utils';
 /**
@@ -115,16 +115,12 @@ export class GenesisInfiniteDatasource {
         this.rowData = new Map();
         /** Blocks waiting for the cache to reach their range. @internal */
         this.pendingBlocks = new Set();
-        /** Highest absolute row index already handed to AG Grid. @internal */
-        this.deliveredRowCount = 0;
         /** False until the first message arrives on the subscription. @internal */
         this.streamStarted = false;
         /** Whether a MORE_ROWS request is awaiting its batch. @internal */
         this.moreRowsInFlight = false;
         /** Whether the current subscription was opened with a CRITERIA_MATCH. @internal */
         this.hasCriteria = false;
-        /** So the MAX_VIEW truncation warning is logged once per subscription. @internal */
-        this.viewTruncationWarned = false;
         this.createSnapshotFunc = options.createSnapshotFunc;
         this.createDataserverStreamFunc = options.createDataserverStreamFunc;
         this.getMoreRowsFunc = options.getMoreRowsFunc;
@@ -371,7 +367,7 @@ export class GenesisInfiniteDatasource {
         };
         // The cache may already cover this block - one batch can span several blocks, and blocks are
         // re-requested after a purge - and once the stream has ended nothing more will arrive.
-        if (this.streamStarted && (this.rowData.size >= endRow || this.moreRows === false)) {
+        if (this.streamStarted && (this.rowData.size >= endRow || this.streamEnded)) {
             this.settleBlock(block, true);
             return;
         }
@@ -395,7 +391,7 @@ export class GenesisInfiniteDatasource {
      * @internal
      */
     pumpMoreRows() {
-        if (this.moreRowsInFlight || this.moreRows === false || this.pendingBlocks.size === 0) {
+        if (this.moreRowsInFlight || this.streamEnded || this.pendingBlocks.size === 0) {
             return;
         }
         // No subscription, or none that has identified itself yet: a MORE_ROWS against a stale
@@ -430,8 +426,6 @@ export class GenesisInfiniteDatasource {
                 if ((error === null || error === void 0 ? void 0 : error.status) === GenesisInfiniteDatasource.HTTP_NOT_FOUND) {
                     logger.warn(`Infinite DATASERVER paging is not available on this connection (MORE_ROWS answered 404, expected over HTTP/feature.forceHttp). ${this.resourceName} is truncated to the ${this.rowData.size} row(s) already delivered; use a websocket connection, or a REQUEST_SERVER resource, to page further.`);
                     this.moreRows = false;
-                    // The MAX_VIEW warning would misdiagnose this truncation as a view cap.
-                    this.viewTruncationWarned = true;
                     this.settleCoveredBlocks();
                     return;
                 }
@@ -445,7 +439,7 @@ export class GenesisInfiniteDatasource {
      * @internal
      */
     handleDataserverMessage(message) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g;
         const messageType = message === null || message === void 0 ? void 0 : message.MESSAGE_TYPE;
         if (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK) {
             // Report it (same messages as the SSRM dataserver resource) - without this a logged-off
@@ -482,7 +476,8 @@ export class GenesisInfiniteDatasource {
             this.notifyLiveChange(filtered);
             return;
         }
-        const solicited = this.moreRowsInFlight || this.pendingBlocks.size > 0 || !this.streamStarted;
+        const answersMoreRows = this.moreRowsInFlight;
+        const solicited = answersMoreRows || this.pendingBlocks.size > 0 || !this.streamStarted;
         this.moreRowsInFlight = false;
         if ((message === null || message === void 0 ? void 0 : message.MORE_ROWS) !== undefined) {
             this.moreRows = message.MORE_ROWS;
@@ -503,10 +498,50 @@ export class GenesisInfiniteDatasource {
                 return;
             }
         }
+        if (!this.streamEnded) {
+            this.notePagingStatus(answersMoreRows && !((_g = filtered === null || filtered === void 0 ? void 0 : filtered.inserts) === null || _g === void 0 ? void 0 : _g.length) && (message === null || message === void 0 ? void 0 : message.MORE_ROWS) === true);
+        }
         this.streamStarted = true;
         this.settleCoveredBlocks();
         this.pumpMoreRows();
     }
+    /**
+     * Stops the walk when the view is full at MAX_VIEW (checked by row count, which saves asking for
+     * the empty page) or a MORE_ROWS came back empty, and says why.
+     * @param emptyReply - Whether this message answered a MORE_ROWS with no rows.
+     * @internal
+     */
+    notePagingStatus(emptyReply) {
+        var _a;
+        const maxView = (_a = this.resourceParams) === null || _a === void 0 ? void 0 : _a.MAX_VIEW;
+        const status = dataserverPagingStatus({
+            moreRows: this.moreRows,
+            emptyReply,
+            rowsHeld: this.rowData.size,
+            maxView,
+        });
+        if (status !== 'view-full' && status !== 'stalled') {
+            return;
+        }
+        this.pagingStopped = status;
+        const warning = describeDataserverPagingStop({
+            status,
+            resourceName: this.resourceName,
+            rowsHeld: this.rowData.size,
+            maxView,
+            emptyReply,
+            // ROWS_COUNT ignores CRITERIA_MATCH, so it is no total for a filtered view.
+            totalRows: this.hasCriteria ? undefined : this.serverRowsCount,
+            attribute: 'max-view',
+        });
+        if (warning) {
+            logger.warn(warning);
+        }
+    }
+    /** Whether the stream will deliver no more rows: the data ran out, or paging stopped. @internal */
+    get streamEnded() {
+        return this.moreRows === false || this.pagingStopped !== undefined;
+    }
     /**
      * Reports a server-pushed change to the host so the grid can catch up.
      * @internal
@@ -551,11 +586,13 @@ export class GenesisInfiniteDatasource {
         }, GenesisInfiniteDatasource.BLOCK_RESOLVE_TIMEOUT_MS);
     }
     /**
-     * Merges a batch into the cumulative cache.
+     * Merges a batch's INSERT and MODIFY rows into the cumulative cache.
+     * @remarks A DELETE never reaches here: any batch carrying one drops the cache instead (see
+     * notifyLiveChange), as removing a delivered row would shift the slice of every later block.
      * @internal
      */
     accumulate(result) {
-        var _a, _b, _c;
+        var _a, _b;
         const rows = new Map(this.rowData);
         (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.forEach((row) => {
             const key = row === null || row === void 0 ? void 0 : row[this.rowId];
@@ -566,41 +603,20 @@ export class GenesisInfiniteDatasource {
             }
             rows.set(key, row);
         });
-        // Live MODIFY rows may be partial, so merge into the cached row instead of clobbering it.
+        // Under a custom row-id a pushed row is identified only by its ROW_REF.
+        const resolveKey = cachedRowKeyResolver(rows, this.rowId);
+        // Live MODIFY rows may be partial, so merge into the cached row instead of clobbering it. A
+        // row resolved through its ROW_REF carries the custom id as undefined; keep the cached one.
         (_b = result.updates) === null || _b === void 0 ? void 0 : _b.forEach((row) => {
-            const key = row === null || row === void 0 ? void 0 : row[this.rowId];
+            const key = resolveKey(row);
             if (key === undefined) {
                 return;
             }
             const existing = rows.get(key);
-            rows.set(key, existing ? Object.assign(Object.assign({}, existing), row) : row);
-        });
-        (_c = result.deletes) === null || _c === void 0 ? void 0 : _c.forEach((row) => {
-            const key = row === null || row === void 0 ? void 0 : row[this.rowId];
-            if (key === undefined) {
-                return;
-            }
-            // Rows already handed to AG Grid sit at fixed absolute indices; removing one from the
-            // cache would shift the slice offsets of every later block.
-            const index = this.cacheIndexOf(rows, key);
-            if (index === -1 || (this.deliveredRowCount > 0 && index < this.deliveredRowCount)) {
-                return;
-            }
-            rows.delete(key);
+            rows.set(key, existing ? Object.assign(Object.assign(Object.assign({}, existing), row), { [this.rowId]: key }) : row);
         });
         this.rowData = rows;
     }
-    /** Position of a key in the cache, or -1. @internal */
-    cacheIndexOf(rows, key) {
-        let index = 0;
-        for (const mapKey of rows.keys()) {
-            if (mapKey === key) {
-                return index;
-            }
-            index += 1;
-        }
-        return -1;
-    }
     /**
      * Settles every pending block the cache now covers.
      * @internal
@@ -608,7 +624,7 @@ export class GenesisInfiniteDatasource {
     settleCoveredBlocks() {
         // Iterate a copy: settling a block removes it from the set.
         for (const block of [...this.pendingBlocks]) {
-            if (this.rowData.size >= block.endRow || this.moreRows === false) {
+            if (this.rowData.size >= block.endRow || this.streamEnded) {
                 this.settleBlock(block, true);
             }
         }
@@ -630,16 +646,15 @@ export class GenesisInfiniteDatasource {
             return;
         }
         const rows = [...this.rowData.values()].slice(block.startRow, block.endRow);
-        this.deliveredRowCount = Math.max(this.deliveredRowCount, block.startRow + rows.length);
-        // Once the stream reports no more rows the cache is the whole dataset, filter included.
-        // Before that, an unfiltered total gives the grid an accurate scrollbar, while a filtered
-        // view has to stay open-ended - see serverRowsCount.
-        const lastRow = this.moreRows === false
+        // Once the stream has ended the cache is every row the grid can have, filter included.
+        // Before that, an unfiltered total gives the grid an accurate scrollbar, capped at MAX_VIEW
+        // since the view never holds more, while a filtered view has to stay open-ended - see
+        // serverRowsCount.
+        const lastRow = this.streamEnded
             ? this.rowData.size
-            : this.hasCriteria
+            : this.hasCriteria || this.serverRowsCount === undefined
                 ? -1
-                : ((_a = this.serverRowsCount) !== null && _a !== void 0 ? _a : -1);
-        this.warnIfViewTruncated();
+                : Math.min(this.serverRowsCount, resolveMaxView((_a = this.resourceParams) === null || _a === void 0 ? void 0 : _a.MAX_VIEW));
         logger.debug('Infinite DATASERVER block settled', {
             startRow: block.startRow,
             endRow: block.endRow,
@@ -689,26 +704,6 @@ export class GenesisInfiniteDatasource {
             (_b = this.onRowsWithdrawnFunc) === null || _b === void 0 ? void 0 : _b.call(this, withdrawnRowIds);
         }
     }
-    /**
-     * Warns when the view filled up before the data ran out.
-     * @remarks The server stops sending at MAX_VIEW rows and reports MORE_ROWS false, which is
-     * indistinguishable from the end of the data - the grid would silently show a truncated view
-     * and a row count smaller than the resource's. Raising `max-view` past the row count is the
-     * fix, so say so rather than leaving it to be discovered.
-     * @internal
-     */
-    warnIfViewTruncated() {
-        var _a, _b;
-        if (this.viewTruncationWarned ||
-            this.moreRows !== false ||
-            this.hasCriteria ||
-            this.serverRowsCount === undefined ||
-            this.rowData.size >= this.serverRowsCount) {
-            return;
-        }
-        this.viewTruncationWarned = true;
-        logger.warn(`${this.resourceName} stopped at ${this.rowData.size} of ${this.serverRowsCount} rows: the DATASERVER view is capped by MAX_VIEW (${(_b = (_a = this.resourceParams) === null || _a === void 0 ? void 0 : _a.MAX_VIEW) !== null && _b !== void 0 ? _b : 'server default'}). Raise max-view past the row count to reach the rest.`);
-    }
     /** @internal */
     failAllPendingBlocks() {
         // Iterate a copy: settling a block removes it from the set.
@@ -740,12 +735,11 @@ export class GenesisInfiniteDatasource {
         this.subscriptionKey = undefined;
         this.sourceRef = undefined;
         this.rowData = new Map();
-        this.deliveredRowCount = 0;
         this.streamStarted = false;
         this.serverRowsCount = undefined;
         this.hasCriteria = false;
-        this.viewTruncationWarned = false;
         this.moreRows = undefined;
+        this.pagingStopped = undefined;
         this.moreRowsInFlight = false;
     }
     /**

package/dist/esm/datasource/server-side.resource-base.js

@@ -1,5 +1,5 @@
 import { __awaiter, __decorate } from "tslib";
-import { Auth, Connect } from '@genesislcap/foundation-comms';
+import { Auth, Connect, resolveMaxView, } from '@genesislcap/foundation-comms';
 import { UUID } from '@genesislcap/foundation-utils';
 import { DeliveredBlockLedger } from './delivered-block.ledger';
 import { convertDateFilterToCriteria, convertNumberFilterToCriteria, convertSetFilterToCriteria, convertTextFilterToCriteria, } from './filter.utils';
@@ -284,17 +284,20 @@ export class BaseServerSideDatasource {
         const currentLastRowNumber = params.request.endRow;
         this.calculatedRowsCount = this.clientRowsCount || currentLastRowNumber;
         let rowCount;
+        // The cap GSF applies: a MAX_VIEW of 0 (what an empty or non-numeric `max-view` arrives as) is
+        // an unlimited view, not an empty one, and a missing one is the server default of 1000.
+        const viewCap = resolveMaxView(this.maxView);
         // Infinite scroll: getRows() only resolves a block once the cumulative row cache covers
         // its full extent or the stream reported no more data, so blocks are either full or final.
         if (!this.moreRows) {
             // Dataset ends here: rowData.size is the deduplicated loaded count. Deliberately not
             // serverRowsCount (GSF's ROWS_COUNT ignores CRITERIA_MATCH) nor clientRowsCount
             // (non-deduplicated running sum, overcounts on live streams).
-            rowCount = Math.min(this.rowData.size, this.maxView);
+            rowCount = Math.min(this.rowData.size, viewCap);
         }
-        else if (this.rowData.size >= this.maxView) {
+        else if (this.rowData.size >= viewCap) {
             // Hard cap - the view can't grow past maxView.
-            rowCount = this.maxView;
+            rowCount = viewCap;
         }
         else {
             // Full block, more may follow: leave undefined so AG Grid keeps requesting blocks

package/dist/esm/datasource/server-side.resource-dataserver.js

@@ -1,8 +1,8 @@
 import { __awaiter } from "tslib";
-import { MessageType, logger, } from '@genesislcap/foundation-comms';
+import { dataserverPagingStatus, describeDataserverPagingStop, MessageType, logger, } from '@genesislcap/foundation-comms';
 import { DOM } from '@microsoft/fast-element';
 import { getAvailableIndexes, getAvailableIndexFields } from '../utils';
-import { filterDataserverResult } from './dataserver-result.filter';
+import { cachedRowKeyResolver, filterDataserverResult } from './dataserver-result.filter';
 import { BaseServerSideDatasource } from './server-side.resource-base';
 /**
  * The DATASERVER IServerSideDatasource implementation, used for SSRM (Server-Side Row Model) in the grid.
@@ -69,6 +69,8 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             this.structuralPushPending = false;
             this.streamStarted = false;
             this.moreRowsInFlight = false;
+            this.pagingStopped = undefined;
+            this.reportedRowsCount = undefined;
             yield _super.refreshDatasource.call(this, params);
         });
     }
@@ -99,9 +101,10 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                 ? Number(params.request.endRow)
                 : blockStartRow + Number(this.maxRows);
             // Infinite scroll keeps a session-cumulative row cache (see handleCurrentStreamLoad);
-            // when it already covers this block, or the stream ended, no further stream messages
-            // will arrive for this request - resolve it synchronously from the cache.
-            const blockAlreadyCovered = this.currentSequenceId >= 1 && (this.rowData.size >= blockEndRow || !this.moreRows);
+            // when it already covers this block, or the stream ended or the view filled, no further
+            // stream messages will arrive for this request - resolve it synchronously from the cache.
+            const blockAlreadyCovered = this.currentSequenceId >= 1 &&
+                (this.rowData.size >= blockEndRow || !this.moreRows || this.pagingStopped !== undefined);
             // A re-read is the moment the grid asks for current rows. When the cache holds a change the
             // grid never saw (a DELETE it was not told about), serving the slice would hand back the
             // deleted row, so refresh instead: the grid drops every block and re-reads from the server.
@@ -205,7 +208,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                     this.completeEmptyResult(params);
                     return;
                 }
-                if (this.rowData.size >= blockEndRow || !this.moreRows) {
+                if (this.rowData.size >= blockEndRow || !this.moreRows || this.pagingStopped !== undefined) {
                     DOM.queueUpdate(() => resolveBlock(safetyTimer));
                 }
             };
@@ -236,7 +239,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
      * @internal
      */
     dispatchStreamMessage(dataserverResult) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g;
         const messageType = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.MESSAGE_TYPE;
         if (messageType &&
             (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
@@ -245,8 +248,12 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             }
             return;
         }
+        const answersMoreRows = this.moreRowsInFlight;
         if ((dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.MORE_ROWS) !== undefined) {
             this.moreRows = dataserverResult.MORE_ROWS;
+            // Only replies carry MORE_ROWS, and an empty one carries no ROW either: it still answers
+            // the request, so a later push must not be taken for the page.
+            this.moreRowsInFlight = false;
         }
         if (dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.ROW) {
             const nextMessage = filterDataserverResult(dataserverResult, this.rowId);
@@ -262,7 +269,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             // prepended it to the cache and shifted every later block's slice against the grid.
             const carriesPushedChanges = ((_b = (_a = nextMessage.updates) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0 || ((_d = (_c = nextMessage.deletes) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0;
             const solicited = !carriesPushedChanges &&
-                (this.moreRowsInFlight || this.pendingBlocks.size > 0 || !this.streamStarted);
+                (answersMoreRows || this.pendingBlocks.size > 0 || !this.streamStarted);
             this.moreRowsInFlight = false;
             this.streamStarted = true;
             this.handleCurrentStreamLoad(nextMessage, solicited);
@@ -272,12 +279,72 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                 if (this.serverRowsCount === 0) {
                     this.serverRowsCount = (_e = dataserverResult.ROWS_COUNT) !== null && _e !== void 0 ? _e : this.rowData.size;
                 }
+                if (typeof dataserverResult.ROWS_COUNT === 'number') {
+                    this.reportedRowsCount = dataserverResult.ROWS_COUNT;
+                }
             }
         }
+        // Only when paging off the server's cursor: under VIEW_NUMBER pagination GSF sizes the view to
+        // a single page, which never fills.
+        if (!(Number((_f = this.resourceParams) === null || _f === void 0 ? void 0 : _f.VIEW_NUMBER) > 0)) {
+            this.notePagingStatus(answersMoreRows && !((_g = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.ROW) === null || _g === void 0 ? void 0 : _g.length) && (dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.MORE_ROWS) === true);
+        }
         for (const block of this.pendingBlocks) {
             block.handle(dataserverResult);
         }
     }
+    /**
+     * Rows the server's view holds, as far as the cache knows: deleted rows kept as tombstones
+     * below the delivered watermark have already left it.
+     * @internal
+     */
+    get viewRowsHeld() {
+        return this.rowData.size - this.retainedDeletedRowIds.size;
+    }
+    /**
+     * Stops paging when the view is full at MAX_VIEW (checked by row count, which saves asking for
+     * the empty page) or a MORE_ROWS came back empty, says why, and pages again once a full view
+     * shrinks.
+     * @param emptyReply - Whether this message answered a MORE_ROWS with no rows.
+     * @internal
+     */
+    notePagingStatus(emptyReply) {
+        const status = dataserverPagingStatus({
+            moreRows: this.moreRows,
+            emptyReply,
+            rowsHeld: this.viewRowsHeld,
+            maxView: this.maxView,
+        });
+        if (status === 'more' && this.pagingStopped === 'view-full') {
+            this.pagingStopped = undefined;
+            return;
+        }
+        if ((status !== 'view-full' && status !== 'stalled') || this.pagingStopped) {
+            return;
+        }
+        this.pagingStopped = status;
+        const warning = describeDataserverPagingStop({
+            status,
+            resourceName: this.resourceName,
+            rowsHeld: this.viewRowsHeld,
+            maxView: this.maxView,
+            emptyReply,
+            // ROWS_COUNT ignores CRITERIA_MATCH, so it is no total for a filtered view.
+            totalRows: this.getResourceParam('CRITERIA_MATCH') ? undefined : this.reportedRowsCount,
+            attribute: 'max-view',
+        });
+        if (warning) {
+            logger.warn(warning);
+        }
+    }
+    /**
+     * Once paging stops the dataset ends where the cache does, so the grid shows no rows past it.
+     * @internal
+     */
+    getCorrectRowCount(params) {
+        const rowCount = super.getCorrectRowCount(params);
+        return this.pagingStopped ? this.rowData.size : rowCount;
+    }
     /**
      * Dataserver-specific sorting setup that validates columns are part of an index.
      * This is required because dataserver needs indexed columns for efficient sorting.
@@ -354,6 +421,8 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             this.structuralPushPending = false;
             this.streamStarted = false;
             this.moreRowsInFlight = false;
+            this.pagingStopped = undefined;
+            this.reportedRowsCount = undefined;
             yield _super.destroy.call(this);
         });
     }
@@ -382,18 +451,21 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                 this.structuralPushPending = true;
             }
         });
+        // Under a custom row-id a pushed row is identified only by its ROW_REF.
+        const resolveKey = cachedRowKeyResolver(rows, this.rowId);
         // Live QUERY_UPDATE messages can arrive while a block is pending: MODIFY rows may be
-        // partial, so merge into the cached row instead of clobbering it.
+        // partial, so merge into the cached row instead of clobbering it. A row resolved through its
+        // ROW_REF carries the custom id as undefined; keep the cached one.
         (_b = result.updates) === null || _b === void 0 ? void 0 : _b.forEach((updateData) => {
-            const key = updateData === null || updateData === void 0 ? void 0 : updateData[this.rowId];
+            const key = resolveKey(updateData);
             if (key === undefined) {
                 return;
             }
             const existing = rows.get(key);
-            rows.set(key, existing ? Object.assign(Object.assign({}, existing), updateData) : updateData);
+            rows.set(key, existing ? Object.assign(Object.assign(Object.assign({}, existing), updateData), { [this.rowId]: key }) : updateData);
         });
         (_c = result.deletes) === null || _c === void 0 ? void 0 : _c.forEach((deleteData) => {
-            const key = deleteData === null || deleteData === void 0 ? void 0 : deleteData[this.rowId];
+            const key = resolveKey(deleteData);
             if (key === undefined || !rows.has(key)) {
                 return;
             }

package/dist/esm/grid-pro-genesis-datasource/grid-pro-genesis-datasource.js

@@ -1,5 +1,5 @@
 import { __awaiter, __decorate } from "tslib";
-import { MessageType, ResourceType, dataServerResultFilter, normaliseCriteria, } from '@genesislcap/foundation-comms';
+import { MessageType, ResourceType, dataServerResultFilter, dataserverPagingStatus, describeDataserverPagingStop, normaliseCriteria, } from '@genesislcap/foundation-comms';
 import { LifecycleMixin } from '@genesislcap/foundation-utils';
 import { DOM, attr, customElement } from '@microsoft/fast-element';
 import { BehaviorSubject, EMPTY } from 'rxjs';
@@ -60,6 +60,8 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
         this.requiresFullRowDataAndColDefs = true;
         this._lastMoreRows = false;
         this._isMoreRowsResult = false;
+        /** How many MORE_ROWS sent by loadMore() are awaiting their reply. @internal */
+        this._pendingLoadMore = 0;
         this._nextOffset = 0;
         this._loadMoreCount = 0;
         this.onDatasourceReady = () => {
@@ -195,6 +197,9 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
         this.clearRowData();
         this._lastMoreRows = false;
         this._isMoreRowsResult = false;
+        this._pendingLoadMore = 0;
+        this._serverMoreRows = undefined;
+        this._pagingStopped = undefined;
         this._nextOffset = 0;
         this._loadMoreCount = 0;
         this.$emit(datasourceEventNames.destroy);
@@ -334,6 +339,9 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
             // Reset load more tracking on reload
             this._nextOffset = 0;
             this._loadMoreCount = 0;
+            this._pendingLoadMore = 0;
+            this._serverMoreRows = undefined;
+            this._pagingStopped = undefined;
             this.datasource.updateLoadMoreCount(0);
             this.datasource.stream = undefined;
             this.clearRowData(withoutColumnDefs);
@@ -401,24 +409,22 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
                         return;
                     }
                     this.dataSubWasLoggedOff = false;
-                    if (hasMoreRowsInResult) {
-                        this.updateLoadMoreStatus(result.MORE_ROWS, result.SOURCE_REF);
-                    }
+                    const answersLoadMore = hasMoreRowsInResult && this.takeLoadMoreReply();
                     if (result.ROW) {
-                        const nextMessage = dataServerResultFilter(result);
-                        this.handleStreamResult(nextMessage);
-                        if (hasMoreRowsInResult && result.MORE_ROWS !== this._lastMoreRows) {
-                            const moreRowsDetail = {
-                                moreRows: result.MORE_ROWS,
-                                sourceRef: result.SOURCE_REF,
-                            };
-                            this.$emit(gridProGenesisDatasourceEventNames.moreRowsChanged, moreRowsDetail);
-                            this._lastMoreRows = result.MORE_ROWS;
-                        }
+                        this.handleStreamResult(dataServerResultFilter(result));
                     }
                     else {
                         this.handleStreamResult(result);
                     }
+                    // Read after the rows are applied, so a push that fills or shrinks the view counts.
+                    const moreRows = this.notePagingStatus(result, hasMoreRowsInResult, answersLoadMore);
+                    if (moreRows !== undefined && (hasMoreRowsInResult || moreRows !== this._lastMoreRows)) {
+                        this.updateLoadMoreStatus(moreRows, result.SOURCE_REF);
+                        // REQUEST_SERVER pages by OFFSET and has never fired more-rows-changed.
+                        if (!this.isRequestServer) {
+                            this.emitMoreRowsChanged(moreRows, result.SOURCE_REF);
+                        }
+                    }
                 });
             }
             catch (error) {
@@ -453,6 +459,75 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
             this.applyDataserverData(result);
         }
     }
+    /**
+     * Counts off one reply to an outstanding loadMore().
+     * @returns Whether a loadMore() was awaiting this reply.
+     * @internal
+     */
+    takeLoadMoreReply() {
+        const answersLoadMore = this._pendingLoadMore > 0;
+        this._pendingLoadMore = Math.max(0, this._pendingLoadMore - 1);
+        return answersLoadMore;
+    }
+    /**
+     * Works out whether more rows can be loaded after a stream message.
+     * @remarks On DATASERVER, Load More turns off once the view is full at MAX_VIEW, as every
+     * further MORE_ROWS would come back empty (see `dataserverPagingStatus`), or after a MORE_ROWS
+     * came back empty while the view had room. It turns back on when a full view shrinks, since GSF
+     * fills the freed room on the next MORE_ROWS. A moving view never fills, and under VIEW_NUMBER
+     * pagination the view is a single page, so both follow MORE_ROWS alone, as REQUEST_SERVER does.
+     * @returns Whether more rows can be loaded, or `undefined` before the server has said.
+     * @internal
+     */
+    notePagingStatus(result, hasMoreRowsInResult, answersLoadMore) {
+        var _a;
+        if (hasMoreRowsInResult) {
+            this._serverMoreRows = result.MORE_ROWS;
+        }
+        if (this._serverMoreRows === undefined) {
+            return undefined;
+        }
+        if (this.isRequestServer || Number(this.viewNumber) > 0) {
+            return hasMoreRowsInResult ? this._serverMoreRows : undefined;
+        }
+        // The MAX_VIEW the logon actually sent.
+        const maxView = +this.maxView;
+        const emptyReply = answersLoadMore && result.MORE_ROWS === true && !((_a = result.ROW) === null || _a === void 0 ? void 0 : _a.length);
+        const status = dataserverPagingStatus({
+            moreRows: this._serverMoreRows,
+            emptyReply,
+            rowsHeld: this.rowData.size,
+            maxView,
+            movingView: this.movingView,
+        });
+        if (status === 'more' && this._pagingStopped === 'view-full') {
+            this._pagingStopped = undefined;
+        }
+        else if ((status === 'view-full' || status === 'stalled') && !this._pagingStopped) {
+            this._pagingStopped = status;
+            const warning = describeDataserverPagingStop({
+                status,
+                resourceName: this.resourceName,
+                rowsHeld: this.rowData.size,
+                maxView,
+                emptyReply,
+                attribute: 'max-view',
+            });
+            if (warning) {
+                logger.warn(warning);
+            }
+        }
+        return status === 'more' && !this._pagingStopped;
+    }
+    /** Emits `more-rows-changed` when the availability of more rows changes. @internal */
+    emitMoreRowsChanged(moreRows, sourceRef) {
+        if (moreRows === this._lastMoreRows) {
+            return;
+        }
+        const moreRowsDetail = { moreRows, sourceRef };
+        this.$emit(gridProGenesisDatasourceEventNames.moreRowsChanged, moreRowsDetail);
+        this._lastMoreRows = moreRows;
+    }
     /**
      * Updates the status bar based on more rows status
      * @param moreRows - Whether more rows are available
@@ -661,6 +736,11 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
     loadMore() {
         switch (this.datasource.resourceType) {
             case ResourceType.DATASERVER:
+                // Every further MORE_ROWS comes back empty, and on GSF 8.15 still skips rows.
+                if (this._pagingStopped) {
+                    logger.debug(`loadMore() ignored: paging ${this.resourceName} stopped (${this._pagingStopped})`);
+                    return;
+                }
                 let viewNumber;
                 if (this.viewNumber) {
                     this._loadMoreCount = +this.viewNumber + 1;
@@ -669,7 +749,12 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
                 else {
                     this._loadMoreCount += 1;
                 }
-                this.connect.getMoreRows(this._sourceRef, viewNumber);
+                this._pendingLoadMore += 1;
+                Promise.resolve(this.connect.getMoreRows(this._sourceRef, viewNumber)).catch((error) => {
+                    // No reply is coming, so the next message carrying MORE_ROWS does not answer this one.
+                    this._pendingLoadMore = Math.max(0, this._pendingLoadMore - 1);
+                    logger.error(`Failed to load more rows for ${this.resourceName}`, error);
+                });
                 break;
             case ResourceType.REQUEST_SERVER:
                 this._loadMoreCount += 1;