@genesislcap/foundation-ui 14.488.2 → 14.489.0-GENC-1351.10

package/dist/esm/options-datasource/options-datasource.js

@@ -1,7 +1,8 @@
 var OptionsDatasource_1;
 import { __awaiter, __decorate } from "tslib";
+import { GenesisResources, ResourceType } from '@genesislcap/foundation-comms';
 import { Combobox as FASTComboBox, } from '@microsoft/fast-components';
-import { attr, customElement, DOM, observable } from '@microsoft/fast-element';
+import { attr, customElement, DOM, nullableNumberConverter, observable, } from '@microsoft/fast-element';
 import { BaseDatasource, getPrefix, logger, dataserverCriteriaBuilder as criteriaMatchBuilder, } from '../utils';
 /**
  * Datasource element for select/combobox option loading.
@@ -16,9 +17,57 @@ let OptionsDatasource = OptionsDatasource_1 = class OptionsDatasource extends Ba
         super(...arguments);
         this.emptyDataLabel = 'No matching records';
         this.allowCustomOptions = false;
+        /**
+         * Enables infinite scrolling. Instead of loading everything upfront, only `page-size`
+         * options are loaded initially and the next page is requested when the user scrolls near
+         * the bottom of the dropdown. REQUEST_SERVER resources page by OFFSET; DATASERVER
+         * resources page via MORE_ROWS on a live stream (total still capped by `maxView`).
+         *
+         * @remarks
+         * When paging REQUEST_SERVER resources by OFFSET, set a stable `order-by` — without one
+         * the server has no other guaranteed ordering between requests, so rows can shift across
+         * pages (duplicates/gaps) as the underlying data changes between fetches. Also, when the
+         * parent is a combobox, this forces `async` mode on it (see `Combobox.async`), since only
+         * a page of options is loaded client-side.
+         */
+        this.infiniteScroll = false;
+        /**
+         * Number of options fetched per page when `infinite-scroll` is enabled. Defaults to 20.
+         */
+        this.pageSize = OptionsDatasource_1.defaultPageSize;
         this.initalSelectedValueInitialized = false;
         this.isSnapshot = true;
         this.baseCriteria = '';
+        this.listboxElement = null;
+        this.loadingMoreRows = false;
+        this.renderedOptionsCount = 0;
+        this.lastTopUpScrollHeight = -1;
+        this.emptyDataOption = null;
+        /**
+         * While the dropdown is closed, the listbox has no dimensions and cannot be scrolled,
+         * so re-check whether the visible listbox needs topping up every time it opens. Also
+         * retries attaching the scroll listener if the initial attempt (queued on connect)
+         * missed the listbox because the host hadn't rendered it yet.
+         */
+        this.selectOpenChangeHandler = (e) => {
+            var _a;
+            if (!((_a = e.detail) === null || _a === void 0 ? void 0 : _a.open))
+                return;
+            if (!this.listboxElement) {
+                this.attachListboxScrollListener();
+            }
+            this.topUpVisibleListbox();
+        };
+        this.listboxScrollHandler = () => {
+            const listbox = this.listboxElement;
+            if (!listbox)
+                return;
+            const nearBottom = listbox.scrollTop + listbox.clientHeight >=
+                listbox.scrollHeight - OptionsDatasource_1.scrollLoadThresholdPx;
+            if (nearBottom) {
+                this.loadNextPage();
+            }
+        };
         this.resizeObserverCallback = (entries) => {
             entries.forEach((resizeObserverEntry) => {
                 this.checkOverflow(resizeObserverEntry.target);
@@ -61,6 +110,18 @@ let OptionsDatasource = OptionsDatasource_1 = class OptionsDatasource extends Ba
             this.optionElement = (_b = this.optionElement) !== null && _b !== void 0 ? _b : `${getPrefix(this.select)}-option`;
             this.select.addEventListener('change', this.selectChangeHandler);
             this.resizeObserver = new ResizeObserver(this.resizeObserverCallback);
+            if (this.infiniteScroll) {
+                this.maxRows = this.pageSize > 0 ? this.pageSize : OptionsDatasource_1.defaultPageSize;
+                // Note: the combobox switches itself to async (server-side) filtering when it
+                // detects a slotted infinite-scroll datasource — see Combobox.slottedOptionsChanged
+                this.select.addEventListener('open-change', this.selectOpenChangeHandler);
+                yield this.applyInfiniteScrollFetchMode();
+                // The element may have been disconnected while awaiting the resource type;
+                // attaching listeners then would leak them on a detached tree
+                if (!this.isConnected)
+                    return;
+                DOM.queueUpdate(() => this.attachListboxScrollListener());
+            }
             this.fetchData();
             if (!this.valueField) {
                 logger.warn('Specify field for values in options (e.g value-field="VALUE") and optionally field for label (e.g label-field="NAME")');
@@ -68,10 +129,94 @@ let OptionsDatasource = OptionsDatasource_1 = class OptionsDatasource extends Ba
         });
     }
     disconnectedCallback() {
+        var _a;
         super.disconnectedCallback();
         this.resizeObserver.disconnect();
+        (_a = this.listboxElement) === null || _a === void 0 ? void 0 : _a.removeEventListener('scroll', this.listboxScrollHandler);
+        this.listboxElement = null;
+        this.select.removeEventListener('open-change', this.selectOpenChangeHandler);
         this.select.removeEventListener('change', this.selectChangeHandler);
     }
+    /**
+     * REQUEST_SERVER resources page by OFFSET against one-shot requests, so they keep the
+     * default snapshot mode. DATASERVER resources page via MORE_ROWS, which needs the live
+     * stream's SOURCE_REF, so they switch to stream mode.
+     */
+    applyInfiniteScrollFetchMode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.resourceName || !this.connect.isConnected)
+                return;
+            try {
+                const resourceType = yield this.resources.getResourceTypeFor(this.resourceName);
+                this.isSnapshot = resourceType !== ResourceType.DATASERVER;
+            }
+            catch (e) {
+                logger.warn(`Unable to determine the resource type for ${this.resourceName}`, e);
+            }
+        });
+    }
+    attachListboxScrollListener() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!this.isConnected)
+            return;
+        // Remove before add: this may be a retry (e.g. on open-change) against a listbox
+        // that was already found, so avoid attaching a duplicate listener.
+        (_a = this.listboxElement) === null || _a === void 0 ? void 0 : _a.removeEventListener('scroll', this.listboxScrollHandler);
+        // Prefer the host's public contract, falling back to FAST template internals
+        this.listboxElement =
+            (_e = (_c = (_b = this.select) === null || _b === void 0 ? void 0 : _b.scrollableListbox) !== null && _c !== void 0 ? _c : (_d = this.select) === null || _d === void 0 ? void 0 : _d.listbox) !== null && _e !== void 0 ? _e : (_g = (_f = this.select) === null || _f === void 0 ? void 0 : _f.shadowRoot) === null || _g === void 0 ? void 0 : _g.querySelector('.listbox');
+        if (!this.listboxElement) {
+            logger.warn('Unable to locate listbox element, infinite scroll will not be available.');
+            return;
+        }
+        this.listboxElement.addEventListener('scroll', this.listboxScrollHandler);
+    }
+    loadNextPage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loadingMoreRows || !this.canRequestMoreRows())
+                return;
+            this.loadingMoreRows = true;
+            const isRequestServer = this.datasource.resourceType === ResourceType.REQUEST_SERVER;
+            try {
+                // For REQUEST_SERVER this resolves once the page arrives and is rendered (via
+                // handleStreamInserts); for DATASERVER rows arrive on the stream and the flag
+                // resets when they are rendered
+                yield this.requestMoreRows();
+            }
+            catch (_a) {
+                // Already reported by requestMoreRows; allow the next scroll to retry
+                this.loadingMoreRows = false;
+                return;
+            }
+            if (isRequestServer) {
+                this.loadingMoreRows = false;
+            }
+        });
+    }
+    /**
+     * If the loaded options don't fill the visible listbox (so it can't be scrolled),
+     * keep requesting pages until it overflows or the server runs out of rows.
+     */
+    topUpVisibleListbox() {
+        if (!this.infiniteScroll)
+            return;
+        requestAnimationFrame(() => {
+            if (!this.isConnected)
+                return;
+            const listbox = this.listboxElement;
+            // clientHeight is 0 while the dropdown is closed; scrolling isn't possible then anyway
+            if (!listbox || listbox.clientHeight === 0)
+                return;
+            if (listbox.scrollHeight > listbox.clientHeight)
+                return;
+            // If the last top-up didn't grow the listbox (e.g. options hidden by CSS),
+            // fetching further pages would loop until the resource is exhausted
+            if (listbox.scrollHeight === this.lastTopUpScrollHeight)
+                return;
+            this.lastTopUpScrollHeight = listbox.scrollHeight;
+            this.loadNextPage();
+        });
+    }
     fetchData() {
         if (this.select &&
             this.valueField &&
@@ -98,6 +243,13 @@ let OptionsDatasource = OptionsDatasource_1 = class OptionsDatasource extends Ba
         });
     }
     clearData() {
+        // Rows accumulated from a previous stream must not leak into the next fetch
+        // (e.g. when the criteria changes in async mode).
+        this.rowsSyncedWithStream.clear();
+        this.renderedOptionsCount = 0;
+        this.lastTopUpScrollHeight = -1;
+        this.emptyDataOption = null;
+        this.loadingMoreRows = false;
         if (!this.select)
             return;
         Array.from(this.select.children).forEach((x) => {
@@ -119,32 +271,46 @@ let OptionsDatasource = OptionsDatasource_1 = class OptionsDatasource extends Ba
             element.removeAttribute('title');
         }
     }
+    rowToOption(row) {
+        var _a;
+        return {
+            value: row[this.valueField],
+            label: this.labelRowFormatter
+                ? this.labelRowFormatter(row)
+                : this.labelFormatter
+                    ? this.labelFormatter(row[this.labelField])
+                    : this.getDefaultLabelFormat(row[this.labelField], (_a = this.getFieldMetadata(this.labelField)) === null || _a === void 0 ? void 0 : _a.type),
+        };
+    }
+    renderListboxOptions(options) {
+        options.forEach(({ value, label }) => {
+            const option = document.createElement(this.optionElement);
+            option.textContent = label ? label : value;
+            option.value = value;
+            this.select.appendChild(option);
+            this.resizeObserver.observe(option);
+        });
+    }
+    removeEmptyDataOption() {
+        if (this.emptyDataOption) {
+            this.emptyDataOption.remove();
+            this.emptyDataOption = null;
+        }
+    }
     syncComponentData(snapshotData) {
+        this.loadingMoreRows = false;
         const rowData = snapshotData !== null && snapshotData !== void 0 ? snapshotData : Array.from(this.rowsSyncedWithStream.values());
         if (rowData.length > 0) {
-            this.options = rowData.map((row) => {
-                var _a;
-                return ({
-                    value: row[this.valueField],
-                    label: this.labelRowFormatter
-                        ? this.labelRowFormatter(row)
-                        : this.labelFormatter
-                            ? this.labelFormatter(row[this.labelField])
-                            : this.getDefaultLabelFormat(row[this.labelField], (_a = this.getFieldMetadata(this.labelField)) === null || _a === void 0 ? void 0 : _a.type),
-                });
-            });
-            const listboxOptions = this.options.map(({ value, label }) => {
-                const option = document.createElement(this.optionElement);
-                option.textContent = label ? label : value;
-                option.value = value;
-                return option;
-            });
-            listboxOptions.forEach((x) => {
-                this.select.appendChild(x);
-                this.resizeObserver.observe(x);
-            });
+            this.removeEmptyDataOption();
+            this.options = rowData.map((row) => this.rowToOption(row));
+            // In stream mode this is invoked with the full accumulated row set on every
+            // server message, so only options that haven't been rendered yet are appended.
+            const isFirstRenderAfterClear = this.renderedOptionsCount === 0;
+            this.renderListboxOptions(this.options.slice(this.renderedOptionsCount));
+            this.renderedOptionsCount = this.options.length;
+            this.topUpVisibleListbox();
             if (!this.initalSelectedValueInitialized ||
-                (this.select instanceof FASTComboBox && !this.select.async)) {
+                (this.select instanceof FASTComboBox && !this.select.async && isFirstRenderAfterClear)) {
                 this.resetCombobox();
                 const initialLabel = this.getInitialLabel();
                 DOM.queueUpdate(() => {
@@ -167,11 +333,14 @@ let OptionsDatasource = OptionsDatasource_1 = class OptionsDatasource extends Ba
                 });
                 this.initalSelectedValueInitialized = true;
             }
-            const option = document.createElement(this.optionElement);
-            option.textContent = this.emptyDataLabel;
-            option.value = '';
-            option.disabled = true;
-            this.select.appendChild(option);
+            if (this.select && !this.emptyDataOption) {
+                const option = document.createElement(this.optionElement);
+                option.textContent = this.emptyDataLabel;
+                option.value = '';
+                option.disabled = true;
+                this.select.appendChild(option);
+                this.emptyDataOption = option;
+            }
         }
     }
     getInitialLabel() {
@@ -192,16 +361,48 @@ let OptionsDatasource = OptionsDatasource_1 = class OptionsDatasource extends Ba
             this.select.resetCombobox();
         }
     }
+    /**
+     * Appends rows to the already rendered options. Used by REQUEST_SERVER
+     * infinite scroll paging, where each page contains only the new rows.
+     */
     handleStreamInserts(insertedRows) {
-        logger.debug('handleStreamInserts - Method not implemented.');
+        var _a;
+        this.loadingMoreRows = false;
+        if (!(insertedRows === null || insertedRows === void 0 ? void 0 : insertedRows.length))
+            return;
+        this.removeEmptyDataOption();
+        const newOptions = insertedRows.map((row) => this.rowToOption(row));
+        this.options = [...((_a = this.options) !== null && _a !== void 0 ? _a : []), ...newOptions];
+        this.renderListboxOptions(newOptions);
+        this.renderedOptionsCount = this.options.length;
+        this.topUpVisibleListbox();
     }
+    /**
+     * @remarks
+     * Not implemented: rendered options are only ever appended (see `syncComponentData` /
+     * `handleStreamInserts`). For DATASERVER `infinite-scroll`, a live delete/update on a
+     * row already rendered in an open dropdown will not be reflected until the datasource
+     * is refetched (e.g. criteria change) — tracked as a known limitation, not a v1 goal.
+     */
     handleStreamDeletes(deletedRows) {
         logger.debug('handleStreamDeletes - Method not implemented.');
     }
+    /**
+     * @remarks
+     * Not implemented — see {@link OptionsDatasource.handleStreamDeletes}.
+     */
     handleStreamUpdates(updatedRows) {
         logger.debug('handleStreamUpdates - Method not implemented.');
     }
 };
+OptionsDatasource.defaultPageSize = 20;
+/**
+ * Distance from the bottom of the listbox (in px) at which the next page is requested.
+ */
+OptionsDatasource.scrollLoadThresholdPx = 32;
+__decorate([
+    GenesisResources
+], OptionsDatasource.prototype, "resources", void 0);
 __decorate([
     attr({ attribute: 'label-field' })
 ], OptionsDatasource.prototype, "labelField", void 0);
@@ -217,6 +418,12 @@ __decorate([
 __decorate([
     attr({ mode: 'boolean', attribute: 'allow-custom-options' })
 ], OptionsDatasource.prototype, "allowCustomOptions", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'infinite-scroll' })
+], OptionsDatasource.prototype, "infiniteScroll", void 0);
+__decorate([
+    attr({ attribute: 'page-size', converter: nullableNumberConverter })
+], OptionsDatasource.prototype, "pageSize", void 0);
 __decorate([
     observable
 ], OptionsDatasource.prototype, "labelFormatter", void 0);

package/dist/esm/select/select.js

@@ -5,8 +5,19 @@ import { foundationSelectStyles as styles } from './select.styles';
 import { foundationSelectTemplate as template } from './select.template';
 /**
  * @tagname %%prefix%%-select
+ *
+ * @fires open-change - Fired when the dropdown opens or closes. detail: `OpenChangeEventDetail`
  */
 export class Select extends FASTSelect {
+    /**
+     * The scrollable element hosting the dropdown options. Part of the public contract for
+     * slotted datasources (e.g. options-datasource infinite scroll) to observe scrolling.
+     * @public
+     */
+    get scrollableListbox() {
+        var _a, _b;
+        return (_a = this.listbox) !== null && _a !== void 0 ? _a : (_b = this.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('.listbox');
+    }
     /**
      * @internal
      */
@@ -66,6 +77,7 @@ export class Select extends FASTSelect {
         if (!this.collapsible) {
             return;
         }
+        this.$emit('open-change', { open: this.open });
         if (this.open) {
             this.ariaControls = this.listboxId;
             this.ariaExpanded = 'true';

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

@@ -1,5 +1,5 @@
 import { __awaiter, __decorate } from "tslib";
-import { Connect, dataServerResultFilter, Datasource, DatasourceDefaults, DatasourceEventHandler, FieldTypeEnum, MessageType, normaliseCriteria, } from '@genesislcap/foundation-comms';
+import { Connect, dataServerResultFilter, Datasource, DatasourceDefaults, DatasourceEventHandler, FieldTypeEnum, MessageType, normaliseCriteria, ResourceType, } from '@genesislcap/foundation-comms';
 import { formatTimestamp } from '@genesislcap/foundation-utils';
 import { attr, observable } from '@microsoft/fast-element';
 import { FoundationElement } from '@microsoft/fast-foundation';
@@ -24,6 +24,14 @@ export class BaseDatasource extends DatasourceEventHandler(FoundationElement) {
          */
         this.withTimestampFormatting = true;
         this.requiresFullDataRefresh = true;
+        /**
+         * Whether the server reported more rows are available beyond the ones already fetched.
+         */
+        this.moreRowsAvailable = false;
+        /**
+         * The OFFSET to request the next page from, for REQUEST_SERVER paging.
+         */
+        this.nextRequestOffset = 0;
         this.rowsSyncedWithStream = new Map();
         this.dataSubWasLoggedOff = false;
         this.criteriaFromFilters = new Map();
@@ -79,9 +87,11 @@ export class BaseDatasource extends DatasourceEventHandler(FoundationElement) {
     }
     fetchGenesisData() {
         return __awaiter(this, arguments, void 0, function* (withFullInit = true) {
-            var _a;
+            var _a, _b;
             (_a = this.dataSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
             this.dataSub = undefined;
+            this.moreRowsAvailable = false;
+            this.nextRequestOffset = 0;
             this.fetchGeneration += 1;
             const generation = this.fetchGeneration;
             const isStale = () => generation !== this.fetchGeneration;
@@ -94,6 +104,7 @@ export class BaseDatasource extends DatasourceEventHandler(FoundationElement) {
                 this.connect.dataLogoff(this.sourceRef);
                 this.clearData();
             }
+            this.sourceRef = undefined;
             const initOK = yield this.datasource.init(this.datasourceOptions(), requiresMetadataFetch);
             if (isStale())
                 return;
@@ -105,9 +116,11 @@ export class BaseDatasource extends DatasourceEventHandler(FoundationElement) {
                 return;
             }
             if (this.isSnapshot) {
-                const rowData = yield this.datasource.snapshotFiltered();
+                const result = yield this.datasource.snapshot();
                 if (isStale())
                     return;
+                const rowData = this.filterSnapshotResult(result);
+                this.updateRequestPagingState(result, (_b = rowData === null || rowData === void 0 ? void 0 : rowData.length) !== null && _b !== void 0 ? _b : 0, this.initialRequestOffset());
                 this.syncComponentData(rowData);
                 return;
             }
@@ -122,6 +135,9 @@ export class BaseDatasource extends DatasourceEventHandler(FoundationElement) {
                     });
                 }
                 this.sourceRef = result.SOURCE_REF;
+                if (typeof result.MORE_ROWS === 'boolean') {
+                    this.moreRowsAvailable = result.MORE_ROWS;
+                }
                 const messageType = result.MESSAGE_TYPE;
                 if (messageType && messageType === MessageType.LOGOFF_ACK) {
                     this.dataSubWasLoggedOff = true;
@@ -143,6 +159,119 @@ export class BaseDatasource extends DatasourceEventHandler(FoundationElement) {
             yield this.datasource.init(this.datasourceOptions(), true);
         });
     }
+    /**
+     * Whether a further page of rows can be requested from the server.
+     * @public
+     */
+    canRequestMoreRows() {
+        // Deferred callbacks (scroll listeners, rAF) may fire after disconnection,
+        // at which point the datasource has been destroyed
+        if (!this.isConnected || !this.datasource || !this.moreRowsAvailable) {
+            return false;
+        }
+        switch (this.datasource.resourceType) {
+            case ResourceType.REQUEST_SERVER:
+                return true;
+            case ResourceType.DATASERVER:
+                // Dataserver paging needs the live stream's view reference
+                return !!this.sourceRef && !this.dataSubWasLoggedOff;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Requests the next page of rows (up to `maxRows`) from the server.
+     *
+     * @remarks
+     * For DATASERVER resources a MORE_ROWS message is sent against the active stream's view and
+     * the rows are delivered as inserts on the existing stream subscription. For REQUEST_SERVER
+     * resources the next page is requested by OFFSET and delivered via `handleStreamInserts`.
+     * @public
+     */
+    requestMoreRows() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.canRequestMoreRows()) {
+                return;
+            }
+            try {
+                if (this.datasource.resourceType === ResourceType.DATASERVER) {
+                    yield this.connect.getMoreRows(this.sourceRef);
+                    return;
+                }
+                const generation = this.fetchGeneration;
+                const requestedOffset = this.nextRequestOffset;
+                // Re-evaluated from the response; also prevents re-entry while the request is in flight
+                this.moreRowsAvailable = false;
+                const result = yield this.datasource.snapshot({
+                    DETAILS: Object.assign(Object.assign({}, (_a = this.datasource.requestOnlyParams) === null || _a === void 0 ? void 0 : _a.DETAILS), { OFFSET: requestedOffset }),
+                });
+                // The element was refetched (e.g. criteria changed) while this page was in flight
+                if (generation !== this.fetchGeneration)
+                    return;
+                const rows = Array.isArray(result === null || result === void 0 ? void 0 : result.REPLY) ? result.REPLY : [];
+                this.updateRequestPagingState(result, rows.length, requestedOffset);
+                if (rows.length > 0) {
+                    this.handleStreamInserts(rows);
+                }
+            }
+            catch (error) {
+                // Restore: canRequestMoreRows() gated entry above, so this was true before the
+                // failed request. Leaving it false would permanently stop REQUEST_SERVER paging,
+                // since nothing else re-evaluates it until the next full refetch.
+                this.moreRowsAvailable = true;
+                this.handleError({
+                    message: `Failed to request more rows for ${this.resourceName}`,
+                    loggerType: 'error',
+                    loggerArgs: [error],
+                });
+                // Re-thrown so callers can react (e.g. reset their loading state)
+                throw error;
+            }
+        });
+    }
+    /**
+     * Row extraction identical to `Datasource.snapshotFiltered`, kept local so the raw
+     * response (with MORE_ROWS/NEXT_OFFSET paging metadata) remains available.
+     */
+    filterSnapshotResult(result) {
+        if (!result) {
+            return undefined;
+        }
+        if (Array.isArray(result)) {
+            return result;
+        }
+        else if (result.REPLY) {
+            return result.REPLY;
+        }
+        else if (result.ROW) {
+            return dataServerResultFilter(result).inserts;
+        }
+    }
+    updateRequestPagingState(result, rowCount, requestedOffset) {
+        if (Array.isArray(result) || !result) {
+            this.moreRowsAvailable = false;
+            return;
+        }
+        const pagingResult = result;
+        const requestedMaxRows = Number(this.maxRows) || 0;
+        // Honour an explicit MORE_ROWS regardless of rowCount: a page can legitimately come
+        // back empty (e.g. rows filtered server-side) while the server still has more to give,
+        // and forcing moreRowsAvailable to false here would stall scroll paging permanently.
+        this.moreRowsAvailable =
+            typeof pagingResult.MORE_ROWS === 'boolean'
+                ? pagingResult.MORE_ROWS
+                : // Fallback when the server omits MORE_ROWS: a full page suggests more may follow
+                    rowCount > 0 && requestedMaxRows > 0 && rowCount >= requestedMaxRows;
+        this.nextRequestOffset =
+            typeof pagingResult.NEXT_OFFSET === 'number' && pagingResult.NEXT_OFFSET > 0
+                ? pagingResult.NEXT_OFFSET
+                : requestedOffset + rowCount;
+    }
+    initialRequestOffset() {
+        var _a, _b;
+        return Number((_b = (_a = this.datasource.requestOnlyParams) === null || _a === void 0 ? void 0 : _a.DETAILS) === null || _b === void 0 ? void 0 : _b.OFFSET) || 0;
+    }
     datasourceOptions() {
         return {
             criteria: this.buildCriteria(),

package/dist/esm/utils/event-types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/index.js

@@ -1,5 +1,6 @@
 export * from './base-datasource';
 export * from './dom';
+export * from './event-types';
 export * from './logger';
 export * from './options-datasource-utils';
 export * from './tooltip';