@genesislcap/grid-pro 14.201.0 → 14.202.1-alpha-34c59e8.0

package/dist/esm/datasource/server-side.grid-definitions.js

@@ -13,7 +13,7 @@ export function getServerSideFilterParamsByFieldType(type) {
                 buttons: ['reset', 'apply'],
                 closeOnApply: true,
                 closeOnClear: true,
-                suppressAndOrCondition: true,
+                maxNumConditions: 1,
                 filterOptions: [
                     'contains',
                     {
@@ -61,9 +61,22 @@ export function getServerSideFilterParamsByFieldType(type) {
                 buttons: ['reset', 'apply'],
                 closeOnApply: true,
                 closeOnClear: true,
-                suppressAndOrCondition: true,
+                maxNumConditions: 1,
                 browserDatePicker: true,
-                filterOptions: ['equals', 'lessThan', 'greaterThan'],
+                filterOptions: [
+                    'equals',
+                    'lessThan',
+                    'greaterThan',
+                    'inRange',
+                    {
+                        displayKey: 'isToday',
+                        displayName: 'Is today',
+                        numberOfInputs: 0,
+                        predicate: () => true,
+                    },
+                    'blank',
+                    'notBlank',
+                ],
             };
         }
         case FieldTypeEnum.NUMBER: {
@@ -71,8 +84,18 @@ export function getServerSideFilterParamsByFieldType(type) {
                 buttons: ['reset', 'apply'],
                 closeOnApply: true,
                 closeOnClear: true,
-                suppressAndOrCondition: true,
-                filterOptions: ['equals', 'lessThan', 'greaterThan'],
+                maxNumConditions: 1,
+                filterOptions: [
+                    'equals',
+                    'notEqual',
+                    'greaterThan',
+                    'greaterThanOrEqual',
+                    'lessThan',
+                    'lessThanOrEqual',
+                    'inRange',
+                    'blank',
+                    'notBlank',
+                ],
             };
         }
         default: {
@@ -80,8 +103,20 @@ export function getServerSideFilterParamsByFieldType(type) {
                 buttons: ['reset', 'apply'],
                 closeOnApply: true,
                 closeOnClear: true,
-                suppressAndOrCondition: true,
-                filterOptions: ['contains', 'equals'],
+                maxNumConditions: 1,
+                filterOptions: [
+                    'contains',
+                    'equals',
+                    'notEqual',
+                    {
+                        displayKey: 'wordStartsWith',
+                        displayName: 'Word starts with',
+                        numberOfInputs: 1,
+                        predicate: () => true,
+                    },
+                    'blank',
+                    'notBlank',
+                ],
             };
         }
     }

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

@@ -0,0 +1,285 @@
+import { __awaiter, __decorate } from "tslib";
+import { Auth, Connect, logger, } from '@genesislcap/foundation-comms';
+import { UUID } from '@genesislcap/foundation-utils';
+import { getAvailableIndexes, getAvailableIndexFields } from '../utils';
+export class BaseServerSideDatasource {
+    constructor(options) {
+        this.rowData = new Map();
+        /**
+         * The number of rows in the grid. THIS DO NOT CONSIDER CRITERIA_MATCH scenarios.
+         * @internal
+         */
+        this.serverRowsCount = 0;
+        /**
+         * The number of rows in the grid. THIS IS A LOCAL COUNT CONSIDERING CONSIDER CRITERIA_MATCH scenarios.
+         * @internal
+         */
+        this.clientRowsCount = 0;
+        this.moreRows = false;
+        this.calculatedRowsCount = 0;
+        this.currentSequenceId = null;
+        this.reloadResourceDataFunc = options.reloadResourceDataFunc;
+        this.resourceName = options.resourceName;
+        this.resourceParams = options.resourceParams;
+        this.originalCriteriaMatch = options.resourceParams.CRITERIA_MATCH;
+        this.resourceIndexes = options.resourceIndexes;
+        this.resourceColDefs = options.resourceColDefs;
+        this.maxRows = options.maxRows;
+        this.maxView = options.maxView;
+        this.rowId = options.rowId;
+        this.pagination = options.pagination;
+        this.zeroBasedViewNumber = options.zeroBasedViewNumber;
+    }
+    getRows(params) {
+        throw new Error('Method not implemented.');
+    }
+    setupFilteringAndSorting(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const filterModelBeingApplied = params.request.filterModel;
+            const filtersAreBeingApplied = Object.keys(filterModelBeingApplied).length > 0;
+            const filtersAreGettingCleaned = Object.keys(filterModelBeingApplied).length === 0;
+            const filterModelBeingAppliedDiffersFromCurrent = JSON.stringify(filterModelBeingApplied) !== JSON.stringify(this.currentFilterModel);
+            if (filterModelBeingAppliedDiffersFromCurrent || filtersAreBeingApplied) {
+                if (filtersAreGettingCleaned && this.currentFilterModel) {
+                    this.currentFilterModel = null;
+                    this.resourceParams.CRITERIA_MATCH = this.originalCriteriaMatch;
+                    yield this.refreshDatasource(params);
+                    return;
+                }
+                else if (filterModelBeingAppliedDiffersFromCurrent && filtersAreBeingApplied) {
+                    this.currentFilterModel = filterModelBeingApplied;
+                    this.resourceParams.CRITERIA_MATCH = this.buildCriteriaMatchFromFilters();
+                    yield this.refreshDatasource(params);
+                    return;
+                }
+            }
+            const toBeAppliedSortModel = params.request.sortModel;
+            if (((_a = this.currentSortModel) === null || _a === void 0 ? void 0 : _a.length) !== toBeAppliedSortModel.length ||
+                toBeAppliedSortModel.length > 0) {
+                if (toBeAppliedSortModel.length === 0 && this.currentSortModel) {
+                    this.calculatedRowsCount = 0;
+                    this.currentSortModel = null;
+                    this.resourceParams.ORDER_BY = null;
+                    this.resourceParams.REVERSE = null;
+                    yield this.refreshDatasource(params);
+                    return;
+                }
+                else if (toBeAppliedSortModel.length > 0) {
+                    this.currentSortModel = toBeAppliedSortModel;
+                    const coldIdBeingSorted = toBeAppliedSortModel[0].colId; // Not allowing multiple sorts by user
+                    const sortTypeBeingApplied = toBeAppliedSortModel[0].sort;
+                    const orderByAndToBeSortedColIds = this.getOrderByAndToBeSortedColIds(this.resourceIndexes, coldIdBeingSorted);
+                    if (!orderByAndToBeSortedColIds) {
+                        this.calculatedRowsCount = 0;
+                        const availableIndexes = getAvailableIndexes(this.resourceIndexes);
+                        const availableIndexFields = getAvailableIndexFields(this.resourceIndexes);
+                        logger.warn('The FIELD/column (${coldIdBeingSorted}) being sorted is not part of an INDEX, required for the [orderBy] operation. See https://learn.genesis.global/docs/database/data-types/index-entities/');
+                        logger.debug('Available indexes:', availableIndexes);
+                        logger.debug('Columns that can be sorted with the available indexes:', availableIndexFields);
+                        params.fail();
+                        return;
+                    }
+                    else if (JSON.stringify(toBeAppliedSortModel) !== JSON.stringify(this.currentSortModel)) {
+                        this.resourceParams.ORDER_BY = orderByAndToBeSortedColIds.orderBy;
+                        this.resourceParams.REVERSE = sortTypeBeingApplied === 'desc' ? true : false;
+                        yield this.refreshDatasource(params);
+                        return;
+                    }
+                }
+            }
+        });
+    }
+    destroy() {
+        this.rowData = new Map();
+        this.clientRowsCount = 0;
+        this.calculatedRowsCount = 0;
+        this.serverRowsCount = 0;
+        this.currentSequenceId = 0;
+        this.moreRows = false;
+        this.sourceRef = undefined;
+        this.lastSuccessRowData = undefined;
+    }
+    refreshDatasource(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.destroy();
+            yield this.reloadResourceDataFunc({
+                criteria: this.resourceParams.CRITERIA_MATCH,
+                orderBy: this.resourceParams.ORDER_BY,
+                reverse: this.resourceParams.REVERSE,
+            });
+        });
+    }
+    getOrderByAndToBeSortedColIds(map, searchValue) {
+        for (const [key, value] of map.entries()) {
+            const searchIndex = value.findIndex((x) => x === searchValue);
+            if (searchIndex !== -1) {
+                const copy = [...value];
+                const toBeSorted = copy.splice(searchIndex, 1);
+                return { orderBy: key, toBeSorted };
+            }
+        }
+    }
+    buildCriteriaMatchFromFilters() {
+        this.resourceParams.CRITERIA_MATCH = this.originalCriteriaMatch;
+        if (this.resourceParams.CRITERIA_MATCH &&
+            typeof this.resourceParams.CRITERIA_MATCH === 'string') {
+            this.resourceParams.CRITERIA_MATCH = this.resourceParams.CRITERIA_MATCH.split(';');
+        }
+        if (!this.resourceParams.CRITERIA_MATCH) {
+            this.resourceParams.CRITERIA_MATCH = [];
+        }
+        const criteria = this.resourceParams.CRITERIA_MATCH.concat(this.criteriaFromFilters());
+        return criteria.join(' && ');
+    }
+    criteriaFromFilters() {
+        const filters = [];
+        this.getFiltersByType('text').forEach((k) => {
+            if (!this.currentFilterModel[k].filter &&
+                (this.currentFilterModel[k].type === 'false' || this.currentFilterModel[k].type === 'true')) {
+                filters.push(`${k} == ${this.currentFilterModel[k].type}`);
+            }
+            else {
+                switch (this.currentFilterModel[k].type) {
+                    case 'blank':
+                        filters.push(`${k} == ''`);
+                        break;
+                    case 'contains':
+                        filters.push(`Expr.containsIgnoreCase(${k}, '${this.currentFilterModel[k].filter}')`);
+                        break;
+                    case 'equals':
+                        filters.push(`${k} == '${this.currentFilterModel[k].filter}'`);
+                        break;
+                    case 'notBlank':
+                        filters.push(`${k} != ''`);
+                        break;
+                    case 'notEqual':
+                        filters.push(`${k} != '${this.currentFilterModel[k].filter}'`);
+                        break;
+                    case 'wordStartsWith':
+                        filters.push(`Expr.containsWordsStartingWithIgnoreCase(${k}, '${this.currentFilterModel[k].filter}')`);
+                        break;
+                }
+            }
+        });
+        this.getFiltersByType('number').forEach((k) => {
+            const value = this.currentFilterModel[k].filter;
+            const valueTwo = this.currentFilterModel[k].filterTo;
+            switch (this.currentFilterModel[k].type) {
+                case 'equals':
+                    !isNaN(value) && filters.push(`${k} == ${value}`);
+                    break;
+                case 'notEqual':
+                    !isNaN(value) && filters.push(`${k} != ${value}`);
+                    break;
+                case 'greaterThan':
+                    !isNaN(value) && filters.push(`${k} > ${value}`);
+                    break;
+                case 'greaterThanOrEqual':
+                    !isNaN(value) && filters.push(`${k} >= ${value}`);
+                    break;
+                case 'lessThan':
+                    !isNaN(value) && filters.push(`${k} < ${value}`);
+                    break;
+                case 'lessThanOrEqual':
+                    !isNaN(value) && filters.push(`${k} <= ${value}`);
+                    break;
+                case 'inRange':
+                    !isNaN(value) &&
+                        !isNaN(valueTwo) &&
+                        filters.push(`${k} >= ${value} && ${k} <= ${valueTwo}`);
+                    break;
+                case 'blank':
+                    filters.push(`${k} == 0`);
+                    break;
+                case 'notBlank':
+                    filters.push(`${k} != 0`);
+                    break;
+            }
+        });
+        this.getFiltersByType('date').forEach((k) => {
+            var _a, _b;
+            const dateFrom = (_a = this.currentFilterModel[k].dateFrom) === null || _a === void 0 ? void 0 : _a.replace(/-/g, '').replace('T', '-').split(' ')[0];
+            const dateTo = (_b = this.currentFilterModel[k].dateTo) === null || _b === void 0 ? void 0 : _b.replace(/-/g, '').replace('T', '-').split(' ')[0];
+            switch (this.currentFilterModel[k].type) {
+                case 'equals':
+                    filters.push(`Expr.dateIsEqual(${k}, '${dateFrom}')`);
+                    break;
+                case 'lessThan':
+                    filters.push(`Expr.dateIsBefore(${k}, '${dateFrom}')`);
+                    break;
+                case 'greaterThan':
+                    filters.push(`Expr.dateIsAfter(${k}, '${dateFrom}')`);
+                    break;
+                case 'inRange':
+                    filters.push(`Expr.dateIsAfter(${k}, '${dateFrom}') && Expr.dateIsBefore(${k}, '${dateTo}')`);
+                    break;
+                case 'isToday':
+                    const now = new Date();
+                    const year = now.getFullYear();
+                    const month = (now.getMonth() + 1).toString().padStart(2, '0');
+                    const day = now.getDate().toString().padStart(2, '0');
+                    const todayStr = `${year}-${month}-${day} 00:00:00`;
+                    filters.push(`Expr.dateIsEqual(${k}, '${todayStr}')`);
+                    break;
+                case 'blank':
+                    filters.push(`${k} == null`);
+                    break;
+                case 'notBlank':
+                    filters.push(`${k} != null`);
+                    break;
+            }
+        });
+        return filters;
+    }
+    getFiltersByType(filterType) {
+        return Object.keys(this.currentFilterModel)
+            .filter((k) => this.resourceColDefs.findIndex((o) => o.NAME === k) !== -1)
+            .filter((k) => this.currentFilterModel[k].filterType === filterType);
+    }
+    getPageNumber(start, recordsPerPage, totalRecords, zeroBasedViewNumber = true) {
+        if (start > totalRecords) {
+            start = Math.floor((totalRecords - 1) / recordsPerPage) * recordsPerPage + 1;
+        }
+        const currentPageIndex = Math.ceil(start / recordsPerPage);
+        return zeroBasedViewNumber ? currentPageIndex : currentPageIndex + 1;
+    }
+    getCorrectRowCount(params) {
+        const currentLastRowNumber = params.request.endRow;
+        this.calculatedRowsCount = this.clientRowsCount || currentLastRowNumber;
+        const defaultCount = Math.min(this.serverRowsCount, this.maxView);
+        let rowCount;
+        if (this.pagination) {
+            rowCount = !this.resourceParams.CRITERIA_MATCH
+                ? Math.min(this.serverRowsCount, this.maxView)
+                : undefined;
+            if (this.resourceParams.CRITERIA_MATCH) {
+                rowCount = defaultCount;
+            }
+            return rowCount;
+        }
+        if (currentLastRowNumber === this.serverRowsCount) {
+            rowCount = this.serverRowsCount;
+        }
+        else if (currentLastRowNumber > this.maxView ||
+            currentLastRowNumber > this.calculatedRowsCount) {
+            rowCount = Math.min(defaultCount, this.calculatedRowsCount);
+        }
+        else if (!this.moreRows && this.serverRowsCount > this.calculatedRowsCount) {
+            rowCount = this.calculatedRowsCount;
+        }
+        return rowCount;
+    }
+    get isNotFirstViewNumber() {
+        return this.zeroBasedViewNumber ? this.currentSequenceId > 0 : this.currentSequenceId > 1;
+    }
+}
+__decorate([
+    Auth
+], BaseServerSideDatasource.prototype, "auth", void 0);
+__decorate([
+    Connect
+], BaseServerSideDatasource.prototype, "connect", void 0);
+__decorate([
+    UUID
+], BaseServerSideDatasource.prototype, "uuid", void 0);

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

@@ -0,0 +1,132 @@
+import { __awaiter } from "tslib";
+import { logger, MessageType, dataServerResultFilter, } from '@genesislcap/foundation-comms';
+import { DOM } from '@microsoft/fast-element';
+import { BaseServerSideDatasource } from './server-side.resource-base';
+/**
+ * The DATASERVER IServerSideDatasource implementation, used for SSRM (Server-Side Row Model) in the grid.
+ * @alpha
+ */
+export class DataserverServerSideDatasource extends BaseServerSideDatasource {
+    constructor(options) {
+        super(options);
+        this.createDataserverStreamFunc = options.createDataserverStreamFunc;
+    }
+    refreshDatasource(params) {
+        const _super = Object.create(null, {
+            refreshDatasource: { get: () => super.refreshDatasource }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.dataserverStreamSubscription.unsubscribe();
+            this.dataserverStreamSubscription = undefined;
+            yield _super.refreshDatasource.call(this, params);
+        });
+    }
+    getRows(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setupFilteringAndSorting(params);
+            if (this.pagination && !this.isNewPageSize && this.currentSequenceId > 0) {
+                params.success(this.lastSuccessRowData);
+                return;
+            }
+            if (!this.dataserverStream) {
+                this.dataserverStream = yield this.createDataserverStreamFunc(this.resourceParams);
+            }
+            if (this.currentSequenceId >= 1 &&
+                (this.moreRows ||
+                    params.request.startRow >= Number(this.maxRows) ||
+                    params.request.startRow === 0)) {
+                if (this.pagination) {
+                    this.resourceParams.VIEW_NUMBER = this.getPageNumber(params.request.startRow, this.maxRows, this.maxView, this.zeroBasedViewNumber);
+                    // if (this.resourceParams.VIEW_NUMBER === 1) {
+                    //   await this.refreshDatasource(params);
+                    //   return;
+                    // }
+                }
+                this.connect.getMoreRows(this.sourceRef, this.resourceParams.VIEW_NUMBER);
+            }
+            let applyResult = true;
+            this.dataserverStreamSubscription = this.dataserverStream.subscribe((dataserverResult) => {
+                if (applyResult) {
+                    DOM.queueUpdate(() => __awaiter(this, void 0, void 0, function* () {
+                        if (this.resourceParams.CRITERIA_MATCH) {
+                            const updatedInfo = yield this.connect.snapshot(this.resourceName, {
+                                MAX_ROWS: this.maxView,
+                                MAX_VIEW: this.maxView,
+                                CRITERIA_MATCH: this.resourceParams.CRITERIA_MATCH,
+                            });
+                            if (!updatedInfo.ROW && !updatedInfo.ROWS_COUNT) {
+                                logger.warn('No data returned when criteria is applied.');
+                                this.serverRowsCount = 0;
+                                this.clientRowsCount = 0;
+                            }
+                            else {
+                                this.serverRowsCount = this.resourceParams.CRITERIA_MATCH
+                                    ? updatedInfo.ROW.length
+                                    : updatedInfo.ROWS_COUNT;
+                            }
+                        }
+                        this.applyServerSideData(params, dataserverResult);
+                        applyResult = false;
+                    }));
+                }
+            });
+        });
+    }
+    applyServerSideData(params, result) {
+        var _a;
+        const messageType = result.MESSAGE_TYPE;
+        if (messageType &&
+            (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
+            params.fail();
+            return;
+        }
+        this.moreRows = result.MORE_ROWS;
+        if (result.ROW) {
+            const nextMessage = dataServerResultFilter(result);
+            this.handleCurrentStreamLoad(nextMessage);
+        }
+        else {
+            this.rowData = new Map();
+            const successRowData = { rowData: [] };
+            successRowData.rowCount = 0;
+            params.success(successRowData);
+            return;
+        }
+        this.currentSequenceId = result.SEQUENCE_ID;
+        if (this.currentSequenceId === 1) {
+            this.sourceRef = result.SOURCE_REF;
+            if (this.serverRowsCount === 0) {
+                this.serverRowsCount = (_a = result.ROWS_COUNT) !== null && _a !== void 0 ? _a : this.rowData.size;
+            }
+        }
+        const successRowData = {
+            rowData: Array.from(this.rowData.values()),
+        };
+        successRowData.rowCount = this.getCorrectRowCount(params);
+        this.lastSuccessRowData = successRowData;
+        params.success(successRowData);
+    }
+    destroy() {
+        const _super = Object.create(null, {
+            destroy: { get: () => super.destroy }
+        });
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.dataserverStream = undefined;
+            (_a = this.dataserverStreamSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+            this.dataserverStreamSubscription = undefined;
+            yield _super.destroy.call(this);
+        });
+    }
+    handleCurrentStreamLoad(result) {
+        var _a, _b;
+        if (!result)
+            return;
+        const rows = new Map();
+        (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.forEach((insertData) => {
+            rows.set(insertData[this.rowId], insertData);
+        });
+        this.clientRowsCount += (_b = result.inserts.length) !== null && _b !== void 0 ? _b : 0;
+        this.rowData = rows;
+    }
+}

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

@@ -0,0 +1,131 @@
+import { __awaiter } from "tslib";
+import { MessageType, } from '@genesislcap/foundation-comms';
+import { logger } from '../utils';
+import { BaseServerSideDatasource } from './server-side.resource-base';
+/**
+ * The REQUEST_SERVER IServerSideDatasource implementation, used for SSRM (Server-Side Row Model) in the grid.
+ * @alpha
+ */
+export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.createReqRepRequestFunc = options.createReqRepRequestFunc;
+        if (!((_a = options.resourceParams) === null || _a === void 0 ? void 0 : _a.VIEW_NUMBER)) {
+            this.resourceParams.VIEW_NUMBER = this.zeroBasedViewNumber ? 0 : 1;
+        }
+    }
+    getRows(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setupFilteringAndSorting(params);
+            if (this.pagination && !this.isNewPageSize && this.currentSequenceId > 0) {
+                params.success(this.lastSuccessRowData);
+                return;
+            }
+            if (this.currentSequenceId !== null && this.currentSequenceId >= 0 && this.moreRows) {
+                if (this.pagination) {
+                    this.resourceParams.VIEW_NUMBER = this.getPageNumber(params.request.startRow, this.maxRows, this.maxView);
+                }
+                else {
+                    this.resourceParams.VIEW_NUMBER += 1;
+                }
+            }
+            const requestParams = {
+                DETAILS: {
+                    CRITERIA_MATCH: this.resourceParams.CRITERIA_MATCH,
+                    MAX_ROWS: this.resourceParams.MAX_ROWS,
+                    VIEW_NUMBER: this.resourceParams.VIEW_NUMBER,
+                },
+            };
+            const requestResult = yield this.createReqRepRequestFunc(requestParams);
+            // TODO: massive limitation on the GSF. It should return -1 if it's already the last view (but it doesn't, next will have 0 rows then the NEXT_VIEW=-1).
+            let isLastView = false;
+            if (requestResult.NEXT_VIEW !== -1) {
+                const preCheckRequestParams = Object.assign(Object.assign({}, requestParams), { DETAILS: Object.assign(Object.assign({}, requestParams.DETAILS), { VIEW_NUMBER: requestResult.NEXT_VIEW }) });
+                const moreRowsPreCheck = yield this.createReqRepRequestFunc(preCheckRequestParams);
+                isLastView = moreRowsPreCheck.NEXT_VIEW === -1;
+            }
+            let applyResult = true;
+            if (applyResult) {
+                this.applyServerSideData(params, requestResult, isLastView);
+                applyResult = false;
+            }
+        });
+    }
+    applyServerSideData(params, result, isLastView) {
+        var _a;
+        const messageType = result.MESSAGE_TYPE;
+        if (messageType &&
+            (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
+            params.fail();
+            return;
+        }
+        this.moreRows =
+            !isLastView && result.NEXT_VIEW !== -1 && result.NEXT_VIEW > this.resourceParams.VIEW_NUMBER;
+        if (result.REPLY) {
+            this.handleCurrentStreamLoad(result.REPLY);
+        }
+        else {
+            this.rowData = new Map();
+            const successRowData = { rowData: [] };
+            successRowData.rowCount = 0;
+            params.success(successRowData);
+            return;
+        }
+        this.currentSequenceId = this.resourceParams.VIEW_NUMBER; // result.NEXT_VIEW > 0 ? result.NEXT_VIEW - 1 : 0;
+        this.sourceRef = result.SOURCE_REF;
+        this.serverRowsCount += (_a = result.ROWS_COUNT) !== null && _a !== void 0 ? _a : this.rowData.size;
+        const successRowData = {
+            rowData: Array.from(this.rowData.values()),
+        };
+        successRowData.rowCount = this.getCorrectRowCount(params);
+        this.lastSuccessRowData = successRowData;
+        params.success(successRowData);
+    }
+    getCorrectRowCount(params) {
+        const lastRow = this.moreRows ? -1 : params.request.startRow + this.serverRowsCount;
+        const currentLastRowNumber = params.request.endRow;
+        this.calculatedRowsCount = this.serverRowsCount || currentLastRowNumber;
+        const defaultCount = Math.min(lastRow, this.maxView);
+        let rowCount;
+        if (this.pagination) {
+            rowCount = !this.resourceParams.CRITERIA_MATCH ? Math.min(lastRow, this.maxView) : undefined;
+            if (this.resourceParams.CRITERIA_MATCH) {
+                rowCount = defaultCount;
+            }
+            if (!this.moreRows && lastRow > this.calculatedRowsCount) {
+                rowCount = this.calculatedRowsCount;
+            }
+            return rowCount;
+        }
+        if (currentLastRowNumber === lastRow) {
+            rowCount = lastRow;
+        }
+        else if (currentLastRowNumber > this.maxView ||
+            currentLastRowNumber > this.calculatedRowsCount) {
+            rowCount = Math.min(defaultCount, this.calculatedRowsCount);
+        }
+        else if (!this.moreRows && lastRow > this.calculatedRowsCount) {
+            rowCount = this.calculatedRowsCount;
+        }
+        return rowCount;
+    }
+    handleCurrentStreamLoad(reply) {
+        if (!reply || reply.length == 0)
+            return;
+        const rows = new Map();
+        reply.forEach((insertData) => {
+            const insertDataRowId = insertData[this.rowId];
+            if (insertDataRowId) {
+                rows.set(insertDataRowId, insertData);
+                return;
+            }
+            const noRowIdMessage = `The specified rowId (${this.rowId}) is not present in the data. Since this is a snapshot (isSnapshot=true), an auto-generated UUID will be used. For custom identifiers, use the 'row-id' attribute.`;
+            logger.error(noRowIdMessage);
+            const tempId = this.uuid.createId();
+            insertData[this.rowId] = tempId;
+            rows.set(tempId, insertData);
+        });
+        this.rowData = rows;
+    }
+}