@genesislcap/grid-pro 11.3.0

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

@@ -0,0 +1,328 @@
+import { __awaiter, __decorate } from "tslib";
+import { Connect, dataServerResultFilter, DatasourceDefaults, extractFieldDefinitions, FieldTypeEnum, MessageType, toFieldMetadata, } from '@genesislcap/foundation-comms';
+import { LifecycleMixin } from '@genesislcap/foundation-utils';
+import { attr, customElement, DOM } from '@microsoft/fast-element';
+import { FoundationElement } from '@microsoft/fast-foundation';
+import { take } from 'rxjs/operators';
+import { dateTimeValueFormatter, dateValueFormatter, getColumnType, getFilterByFieldType, getFilterParamsByFieldType, } from '../grid-pro.definitions';
+import { GridProRendererTypes } from '../grid-pro.types';
+import { logger } from '../utils';
+export class StreamDatasource {
+    constructor(options) {
+        this.rowCount = 0;
+        this.moreRows = false;
+        this.calculatedRowsCount = 0;
+        this.lastSequenceId = 0;
+        this.dataserverStream = options.stream;
+        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.pagination = options.pagination;
+    }
+    getRows(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const toBeAppliedFilterModel = params.request.filterModel;
+            if (JSON.stringify(toBeAppliedFilterModel) !== JSON.stringify(this.currentFilterModel) ||
+                Object.keys(toBeAppliedFilterModel).length > 0) {
+                if (Object.keys(toBeAppliedFilterModel).length === 0 && this.currentFilterModel) {
+                    this.currentFilterModel = null;
+                    this.resourceParams.CRITERIA_MATCH = this.originalCriteriaMatch;
+                    this.restartSubscription();
+                }
+                else if (Object.keys(toBeAppliedFilterModel).length > 0) {
+                    this.currentFilterModel = toBeAppliedFilterModel;
+                    this.resourceParams.CRITERIA_MATCH = this.buildCriteriaMatchFromFilters();
+                    this.restartSubscription();
+                }
+            }
+            const toBeAppliedSortModel = params.request.sortModel;
+            if (toBeAppliedSortModel.length !== ((_a = this.currentSortModel) === null || _a === void 0 ? void 0 : _a.length) ||
+                toBeAppliedSortModel.length > 0) {
+                if (toBeAppliedSortModel.length === 0 && this.currentSortModel) {
+                    this.currentSortModel = null;
+                    this.resourceParams.ORDER_BY = null;
+                    this.resourceParams.REVERSE = null;
+                    this.restartSubscription();
+                }
+                else if (toBeAppliedSortModel.length > 0) {
+                    this.currentSortModel = toBeAppliedSortModel;
+                    const coldIdBeingSorted = this.currentSortModel[0].colId;
+                    const sortTypeBeingApplied = this.currentSortModel[0].sort;
+                    const orderByAndToBeSortedColIds = this.getOrderByAndToBeSortedColIds(this.resourceIndexes, coldIdBeingSorted);
+                    orderByAndToBeSortedColIds.toBeSorted.forEach((colId) => {
+                        this.currentSortModel.push({ sort: sortTypeBeingApplied, colId });
+                    });
+                    this.resourceParams.ORDER_BY = orderByAndToBeSortedColIds.orderBy;
+                    this.resourceParams.REVERSE = sortTypeBeingApplied === 'desc' ? true : false;
+                    this.restartSubscription();
+                }
+            }
+            if (this.moreRows && params.request.startRow >= this.maxRows) {
+                this.connect.getMoreRows(this.streamSourceRef);
+            }
+            this.dataserverStream.pipe(take(1)).subscribe((result) => {
+                var _a, _b;
+                const messageType = result.MESSAGE_TYPE;
+                if (messageType &&
+                    (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
+                    params.fail();
+                    return;
+                }
+                this.moreRows = result.MORE_ROWS;
+                let rowData = [];
+                if (result.ROW) {
+                    const nextMessage = dataServerResultFilter(result);
+                    rowData = this.handleStreamUpdate(nextMessage);
+                }
+                this.lastSequenceId = result.SEQUENCE_ID;
+                if (this.lastSequenceId === 1) {
+                    this.streamSourceRef = result.SOURCE_REF;
+                    this.rowCount = (_a = result.ROWS_COUNT) !== null && _a !== void 0 ? _a : rowData.length;
+                }
+                this.calculatedRowsCount += (_b = rowData === null || rowData === void 0 ? void 0 : rowData.length) !== null && _b !== void 0 ? _b : 0;
+                const successRowData = { rowData };
+                if (this.pagination) {
+                    successRowData.rowCount = Math.min(this.rowCount, this.maxView);
+                }
+                else if (params.request.endRow > this.maxView ||
+                    params.request.endRow > this.calculatedRowsCount) {
+                    successRowData.rowCount = this.calculatedRowsCount;
+                }
+                params.success(successRowData);
+            });
+        });
+    }
+    restartSubscription() {
+        this.connect.dataLogoff(this.streamSourceRef);
+        const streamOnMessage = (message) => message;
+        const onError = (error) => logger.error(error);
+        this.dataserverStream = this.connect.stream(this.resourceName, streamOnMessage, onError, this.resourceParams);
+    }
+    getOrderByAndToBeSortedColIds(map, searchValue) {
+        for (const [key, value] of map.entries()) {
+            const searchIndex = value.findIndex((x) => x === searchValue);
+            if (searchIndex !== -1) {
+                const copy = [...value];
+                copy.splice(searchIndex, 1);
+                return { orderBy: key, toBeSorted: copy };
+            }
+        }
+    }
+    handleStreamUpdate(result) {
+        var _a;
+        if (!result)
+            return;
+        const rows = new Map();
+        (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.forEach((insertData) => {
+            rows.set(insertData.ROW_REF, insertData);
+        });
+        const rowData = Array.from(rows.values());
+        return rowData;
+    }
+    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) => filters.push(`Expr.containsIgnoreCase(${k}, '${this.currentFilterModel[k].filter.toLowerCase()}')`));
+        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);
+    }
+}
+__decorate([
+    Connect
+], StreamDatasource.prototype, "connect", void 0);
+let GridProGenesisDatasourceNext = class GridProGenesisDatasourceNext extends LifecycleMixin(FoundationElement) {
+    constructor() {
+        super(...arguments);
+        this.isSnapshot = false;
+        this.maxRows = DatasourceDefaults.MAX_ROWS_250;
+        this.maxView = DatasourceDefaults.MAX_VIEW_1000;
+        this.pagination = false;
+        this.reverse = false;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        DOM.queueUpdate(() => {
+            if (!this.shouldRunConnect)
+                return;
+            this.init();
+        });
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        DOM.queueUpdate(() => {
+            if (!this.shouldRunDisconnect)
+                return;
+            this.reset();
+        });
+    }
+    init() {
+        if (this.agGrid && this.resourceName && this.connect.isConnected) {
+            this.agGrid.gridOptions = {
+                cacheBlockSize: this.maxRows,
+                defaultColDef: {
+                    filter: true,
+                    resizable: true,
+                    sortable: true,
+                },
+                pagination: this.pagination,
+                paginationPageSize: this.maxRows,
+                rowBuffer: 0,
+                rowModelType: 'serverSide',
+                suppressServerSideInfiniteScroll: false,
+                suppressMultiSort: true,
+                onFilterChanged: (params) => { },
+                onSortChanged: (params) => { },
+            };
+            this.agGrid.addEventListener('onGridReady', () => __awaiter(this, void 0, void 0, function* () {
+                const meta = yield this.connect
+                    .getMetadata(this.resourceName)
+                    .catch((e) => logger.error(e));
+                if (!meta)
+                    return false;
+                this.indexes = this.getResourceIndexes(meta.INDEXES);
+                this.originalFieldDef = extractFieldDefinitions(meta);
+                const fieldMetadata = toFieldMetadata(this.originalFieldDef);
+                const agColumnDefs = this.getAgColumnDefs(fieldMetadata);
+                this.agGrid.gridApi.setColumnDefs(agColumnDefs);
+                const dataserverStream = yield this.createDataserverStream();
+                this.dataserverStream = new StreamDatasource({
+                    stream: dataserverStream,
+                    resourceName: this.resourceName,
+                    resourceParams: this.params,
+                    resourceIndexes: this.indexes,
+                    resourceColDefs: this.originalFieldDef,
+                    maxRows: this.maxRows,
+                    maxView: this.maxView,
+                    pagination: this.pagination,
+                });
+                this.agGrid.gridApi.setServerSideDatasource(this.dataserverStream);
+            }), { once: true });
+            return;
+        }
+        logger.warn(`Application not connected, falling back to local columnDefs/rowData`);
+    }
+    reset() { }
+    get agGrid() {
+        return this.parentElement;
+    }
+    getResourceIndexes(avaialbleIndexes) {
+        const resourceIndexesMap = new Map();
+        avaialbleIndexes === null || avaialbleIndexes === void 0 ? void 0 : avaialbleIndexes.forEach((index) => {
+            resourceIndexesMap.set(index.NAME, index.FIELDS.split(' '));
+        });
+        return resourceIndexesMap;
+    }
+    get params() {
+        const params = {
+            CRITERIA_MATCH: this.criteria,
+            FIELDS: this.fields,
+            MAX_ROWS: this.maxRows,
+            MAX_VIEW: this.maxView,
+            REVERSE: this.reverse,
+        };
+        const keys = Array.from(this.indexes.keys());
+        if (this.orderBy) {
+            if (keys.findIndex((key) => key === this.orderBy) > -1) {
+                params.ORDER_BY = this.orderBy;
+            }
+            else {
+                const validIndexes = keys.map((key) => key);
+                logger.warn('Specified [orderBy] index is not valid and will not be used. See https://learn.genesis.global/docs/database/data-types/index-entities/ - Available indexes:', validIndexes);
+            }
+        }
+        logger.debug('Getting configured params:', params);
+        return params;
+    }
+    createDataserverStream(existingParams = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const streamOnMessage = (message) => message;
+            const onError = (error) => logger.error(error);
+            return this.connect.stream(this.resourceName, streamOnMessage, onError, existingParams !== null && existingParams !== void 0 ? existingParams : this.params);
+        });
+    }
+    getAgColumnDefs(fieldsMetadata) {
+        const colDefsFromGenesisData = fieldsMetadata === null || fieldsMetadata === void 0 ? void 0 : fieldsMetadata.flatMap((field) => {
+            var _a;
+            const cellConfigs = {};
+            cellConfigs.filterParams = getFilterParamsByFieldType(field.type);
+            switch (field.type) {
+                case FieldTypeEnum.BOOLEAN:
+                    if (this.agGrid.autoCellRendererByType) {
+                        cellConfigs.cellRenderer = GridProRendererTypes.boolean;
+                    }
+                    break;
+                case FieldTypeEnum.DATE:
+                    cellConfigs.valueFormatter = dateValueFormatter;
+                    break;
+                case FieldTypeEnum.DATETIME:
+                    cellConfigs.valueFormatter = dateTimeValueFormatter;
+                    break;
+                default:
+                    break;
+            }
+            const templateColDef = (_a = this.agGrid.gridApi) === null || _a === void 0 ? void 0 : _a.getColumnDef(field.name);
+            if (this.agGrid.onlyTemplateColDefs && !templateColDef) {
+                return [];
+            }
+            return Object.assign(Object.assign({ field: field.name, type: getColumnType(field.type), filter: getFilterByFieldType(field.type), sortable: [].concat(...this.indexes.values()).includes(field.name) }, cellConfigs), templateColDef);
+        });
+        const colDefsMergedWithTemplateDefs = this.agGrid.applyTemplateDefinitions(colDefsFromGenesisData);
+        return colDefsMergedWithTemplateDefs;
+    }
+};
+__decorate([
+    Connect
+], GridProGenesisDatasourceNext.prototype, "connect", void 0);
+__decorate([
+    attr
+], GridProGenesisDatasourceNext.prototype, "criteria", void 0);
+__decorate([
+    attr
+], GridProGenesisDatasourceNext.prototype, "fields", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'is-snapshot' })
+], GridProGenesisDatasourceNext.prototype, "isSnapshot", void 0);
+__decorate([
+    attr({ attribute: 'max-rows' })
+], GridProGenesisDatasourceNext.prototype, "maxRows", void 0);
+__decorate([
+    attr({ attribute: 'max-view' })
+], GridProGenesisDatasourceNext.prototype, "maxView", void 0);
+__decorate([
+    attr({ attribute: 'order-by' })
+], GridProGenesisDatasourceNext.prototype, "orderBy", void 0);
+__decorate([
+    attr({ attribute: 'resource-name' })
+], GridProGenesisDatasourceNext.prototype, "resourceName", void 0);
+__decorate([
+    attr({ mode: 'boolean' })
+], GridProGenesisDatasourceNext.prototype, "pagination", void 0);
+__decorate([
+    attr({ mode: 'boolean' })
+], GridProGenesisDatasourceNext.prototype, "reverse", void 0);
+GridProGenesisDatasourceNext = __decorate([
+    customElement({
+        name: 'grid-pro-genesis-datasource-next',
+    })
+], GridProGenesisDatasourceNext);
+export { GridProGenesisDatasourceNext };

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

@@ -0,0 +1,339 @@
+import { __awaiter, __decorate } from "tslib";
+import { Connect, dataServerResultFilter, Datasource, DatasourceDefaults, FieldTypeEnum, MessageType, normaliseCriteria, } from '@genesislcap/foundation-comms';
+import { LifecycleMixin } from '@genesislcap/foundation-utils';
+import { attr, customElement, DOM, observable } from '@microsoft/fast-element';
+import { FoundationElement } from '@microsoft/fast-foundation';
+import { BehaviorSubject } from 'rxjs';
+import { debounceTime, skip, tap } from 'rxjs/operators';
+import { dateTimeValueFormatter, dateValueFormatter, getFilterParamsByFieldType, } from '../grid-pro.definitions';
+import { GridProRendererTypes } from '../grid-pro.types';
+import { logger } from '../utils/logger';
+const criteriaDelimiter = ';';
+const criteriaJoin = ' && ';
+const withoutFullInit = null;
+let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleMixin(FoundationElement) {
+    constructor() {
+        super(...arguments);
+        this.isSnapshot = false;
+        this.maxRows = DatasourceDefaults.MAX_ROWS_250;
+        this.maxView = DatasourceDefaults.MAX_VIEW_1000;
+        this.reverse = false;
+        this.rowId = 'ROW_REF';
+        this.requiresFullRowDataAndColDefs = true;
+        this.rows = new Map();
+        this.dataSubWasLoggedOff = false;
+        this.criteriaFromFilters = new Map();
+        this.update = new BehaviorSubject(new Map());
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        DOM.queueUpdate(() => {
+            if (!this.shouldRunConnect)
+                return;
+            this.init();
+        });
+        this.connectionSub = this.connect._status.subscribe((status) => {
+            if (status === 'connected') {
+                this.agGrid.removeAttribute('ds-disconnected');
+            }
+            else {
+                this.agGrid.setAttribute('ds-disconnected', 'ds-disconnected');
+            }
+        });
+    }
+    disconnectedCallback() {
+        var _a;
+        super.disconnectedCallback();
+        DOM.queueUpdate(() => {
+            if (!this.shouldRunDisconnect)
+                return;
+            this.reset();
+        });
+        (_a = this.connectionSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    }
+    deepClone() {
+        const copy = super.deepClone();
+        copy.deferredGridOptions = structuredClone(this.deferredGridOptions);
+        copy.request = structuredClone(this.request);
+        return copy;
+    }
+    get agGrid() {
+        return this.parentElement;
+    }
+    init() {
+        if (this.agGrid && this.resourceName && this.connect.isConnected) {
+            const gridOptions = Object.assign({ getRowId: (params) => params.data[this.rowId] }, this.deferredGridOptions);
+            this.agGrid.gridOptions = Object.assign({}, gridOptions);
+            this.agGrid.addEventListener('onGridReady', () => __awaiter(this, void 0, void 0, function* () {
+                yield this.loadResourceData();
+            }), { once: true });
+            const filterDebounceTime = 600;
+            this.updateSub = this.update
+                .pipe(skip(1), debounceTime(filterDebounceTime), tap((f) => logger.debug('filters (debounced): ', f)))
+                .subscribe((value) => {
+                this.loadResourceData(withoutFullInit);
+            });
+            return;
+        }
+        logger.warn(`Application not connected, falling back to local columnDefs/rowData`);
+    }
+    reset() {
+        var _a, _b;
+        (_a = this.dataSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        (_b = this.updateSub) === null || _b === void 0 ? void 0 : _b.unsubscribe();
+        this.requiresFullRowDataAndColDefs = true;
+        this.clearRowData();
+    }
+    clearRowData() {
+        var _a, _b;
+        this.rows = new Map();
+        (_b = (_a = this.agGrid) === null || _a === void 0 ? void 0 : _a.gridApi) === null || _b === void 0 ? void 0 : _b.setRowData([]);
+    }
+    updateRowData(rowData) {
+        const agColumnDefs = this.getAgColumnDefs(this.datasource.fieldMetadata);
+        if (agColumnDefs.length > 0) {
+            this.agGrid.gridApi.setColumnDefs(agColumnDefs);
+        }
+        this.agGrid.gridApi.setRowData(rowData);
+        this.requiresFullRowDataAndColDefs = false;
+    }
+    loadResourceData(withFullInit = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requiresMetadataFetch = withFullInit || !this.datasource.initialized;
+            if (!requiresMetadataFetch) {
+                this.connect.dataLogoff(this.sourceRef);
+                this.clearRowData();
+            }
+            const initOK = yield this.datasource.init(this.datasourceOptions(), requiresMetadataFetch);
+            if (!initOK) {
+                logger.debug(`Genesis Datasource init failed for ${this.resourceName}`);
+                return;
+            }
+            if (this.isSnapshot) {
+                const result = yield this.datasource.snapshot();
+                if (result) {
+                    const rowData = this.handleSnapshot(result);
+                    this.updateRowData(rowData);
+                }
+                return;
+            }
+            logger.debug(`requesting stream for ${this.resourceName}`);
+            this.dataSub = this.datasource.stream.subscribe((result) => {
+                this.sourceRef = result.SOURCE_REF;
+                const messageType = result.MESSAGE_TYPE;
+                if (messageType && messageType === MessageType.LOGOFF_ACK) {
+                    this.dataSubWasLoggedOff = true;
+                    return;
+                }
+                this.dataSubWasLoggedOff = false;
+                if (result.ROW) {
+                    const nextMessage = dataServerResultFilter(result);
+                    this.handleStreamResult(nextMessage);
+                }
+                else {
+                    this.handleStreamResult(result);
+                }
+            });
+        });
+    }
+    handleSnapshot(result) {
+        if (Array.isArray(result))
+            return result;
+        if (result.REPLY) {
+            return result.REPLY;
+        }
+        if (result.ROW) {
+            return dataServerResultFilter(result).inserts;
+        }
+        return result.inserts;
+    }
+    datasourceOptions() {
+        return {
+            criteria: this.buildCriteria(),
+            fields: this.fields,
+            isSnapshot: this.isSnapshot,
+            orderBy: this.orderBy,
+            resourceName: this.resourceName,
+            request: this.request,
+            reverse: this.reverse,
+            maxRows: this.maxRows,
+            maxView: this.maxView,
+        };
+    }
+    handleStreamResult(result) {
+        if (!result)
+            return;
+        const isRequestServer = result.hasOwnProperty('REPLY');
+        if (isRequestServer) {
+            this.applyRequestServerData(result);
+        }
+        else {
+            this.applyDataserverData(result);
+        }
+    }
+    applyRequestServerData(requestServerResult) {
+        var _a, _b;
+        if (!Array.isArray(requestServerResult.REPLY) ||
+            !((_a = requestServerResult.MESSAGE_TYPE) === null || _a === void 0 ? void 0 : _a.startsWith('REP_'))) {
+            logger.error('received invalid RequestServerResult', requestServerResult);
+            return;
+        }
+        if (this.requiresFullRowDataAndColDefs) {
+            if (this.rowId !== 'ROW_REF') {
+                (_b = requestServerResult.REPLY) === null || _b === void 0 ? void 0 : _b.forEach((insertData) => {
+                    this.rows.set(insertData[this.rowId], insertData);
+                });
+            }
+            const rowData = this.rows.size > 0 ? Array.from(this.rows.values()) : requestServerResult.REPLY;
+            this.updateRowData(rowData);
+            return;
+        }
+        this.agTransaction = { add: [], remove: [], update: [] };
+        this.handleStreamInserts(requestServerResult.REPLY);
+        const rowsToDelete = Array.from(this.rows.values()).filter((row) => !requestServerResult.REPLY.includes(row));
+        this.handleStreamDeletes(rowsToDelete);
+        this.agGrid.gridApi.applyTransactionAsync(this.agTransaction);
+    }
+    applyDataserverData(dataServerResult) {
+        var _a;
+        if (this.requiresFullRowDataAndColDefs) {
+            (_a = dataServerResult.inserts) === null || _a === void 0 ? void 0 : _a.forEach((insertData) => {
+                this.rows.set(insertData[this.rowId], insertData);
+            });
+            const rowData = Array.from(this.rows.values());
+            this.updateRowData(rowData);
+            return;
+        }
+        this.agTransaction = { add: [], remove: [], update: [] };
+        this.handleStreamInserts(dataServerResult.inserts);
+        this.handleStreamDeletes(dataServerResult.deletes);
+        this.handleStreamUpdates(dataServerResult.updates);
+        this.agGrid.gridApi.applyTransactionAsync(this.agTransaction);
+    }
+    handleStreamInserts(insertedRows) {
+        insertedRows === null || insertedRows === void 0 ? void 0 : insertedRows.forEach((insertData) => {
+            if (this.rows.has(insertData[this.rowId]) || this.dataSubWasLoggedOff) {
+                const rowToBeUpdated = this.rows.get(insertData[this.rowId]);
+                const updatedRow = Object.assign(Object.assign({}, rowToBeUpdated), insertData);
+                this.agTransaction.update.push(updatedRow);
+            }
+            else {
+                this.agTransaction.add.push(insertData);
+                this.agTransaction.addIndex = 0;
+            }
+            this.rows.set(insertData[this.rowId], insertData);
+        });
+    }
+    handleStreamDeletes(deletedRows) {
+        deletedRows === null || deletedRows === void 0 ? void 0 : deletedRows.forEach((deleteData) => {
+            this.agTransaction.remove.push({ [this.rowId]: deleteData[this.rowId] });
+            this.rows.delete(deleteData[this.rowId]);
+        });
+    }
+    handleStreamUpdates(updatedRows) {
+        updatedRows === null || updatedRows === void 0 ? void 0 : updatedRows.forEach((updateData) => {
+            const rowToBeUpdated = this.rows.get(updateData[this.rowId]);
+            const updatedRow = Object.assign(Object.assign({}, rowToBeUpdated), updateData);
+            this.agTransaction.update.push(updatedRow);
+            this.rows.set(updateData[this.rowId], updatedRow);
+        });
+    }
+    getAgColumnDefs(fieldsMetadata) {
+        const colDefsFromGenesisData = fieldsMetadata === null || fieldsMetadata === void 0 ? void 0 : fieldsMetadata.flatMap((field) => {
+            var _a;
+            const cellConfigs = {};
+            cellConfigs.filterParams = getFilterParamsByFieldType(field.type);
+            switch (field.type) {
+                case FieldTypeEnum.BOOLEAN:
+                    if (this.agGrid.autoCellRendererByType) {
+                        cellConfigs.cellRenderer = GridProRendererTypes.boolean;
+                    }
+                    break;
+                case FieldTypeEnum.DATE:
+                    cellConfigs.valueFormatter = dateValueFormatter;
+                    break;
+                case FieldTypeEnum.DATETIME:
+                    cellConfigs.valueFormatter = dateTimeValueFormatter;
+                    break;
+                default:
+                    break;
+            }
+            const templateColDef = (_a = this.agGrid.gridApi) === null || _a === void 0 ? void 0 : _a.getColumnDef(field.name);
+            if (this.agGrid.onlyTemplateColDefs && !templateColDef) {
+                return [];
+            }
+            if (this.fields && !this.fields.includes(field.name)) {
+                return [];
+            }
+            return Object.assign(Object.assign({ field: field.name }, cellConfigs), templateColDef);
+        });
+        const colDefsMergedWithTemplateDefs = this.agGrid.applyTemplateDefinitions(colDefsFromGenesisData);
+        return colDefsMergedWithTemplateDefs;
+    }
+    buildCriteria() {
+        var _a;
+        const initialCriteria = ((_a = this.criteria) === null || _a === void 0 ? void 0 : _a.split(criteriaDelimiter)) || [];
+        const criteria = initialCriteria.concat(Array.from(this.criteriaFromFilters.values()));
+        return normaliseCriteria(criteria.join(criteriaJoin), criteriaDelimiter);
+    }
+    criteriaChanged(oldCriteria, newCriteria) {
+        const firstCriteria = !oldCriteria && newCriteria;
+        const criteriaNotDuplicate = oldCriteria !== normaliseCriteria(newCriteria, criteriaDelimiter);
+        if (firstCriteria || criteriaNotDuplicate) {
+            DOM.queueUpdate(() => this.loadResourceData(withoutFullInit));
+        }
+    }
+    setFilter(fieldName, newFilter) {
+        this.criteriaFromFilters.set(fieldName, newFilter);
+        this.update.next(this.criteriaFromFilters);
+    }
+    removeFilter(fieldName) {
+        this.criteriaFromFilters.delete(fieldName);
+        this.update.next(this.criteriaFromFilters);
+    }
+};
+__decorate([
+    Connect
+], GridProGenesisDatasource.prototype, "connect", void 0);
+__decorate([
+    Datasource
+], GridProGenesisDatasource.prototype, "datasource", void 0);
+__decorate([
+    observable
+], GridProGenesisDatasource.prototype, "deferredGridOptions", void 0);
+__decorate([
+    attr
+], GridProGenesisDatasource.prototype, "criteria", void 0);
+__decorate([
+    attr
+], GridProGenesisDatasource.prototype, "fields", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'is-snapshot' })
+], GridProGenesisDatasource.prototype, "isSnapshot", void 0);
+__decorate([
+    attr({ attribute: 'max-rows' })
+], GridProGenesisDatasource.prototype, "maxRows", void 0);
+__decorate([
+    attr({ attribute: 'max-view' })
+], GridProGenesisDatasource.prototype, "maxView", void 0);
+__decorate([
+    attr({ attribute: 'order-by' })
+], GridProGenesisDatasource.prototype, "orderBy", void 0);
+__decorate([
+    observable
+], GridProGenesisDatasource.prototype, "request", void 0);
+__decorate([
+    attr({ attribute: 'resource-name' })
+], GridProGenesisDatasource.prototype, "resourceName", void 0);
+__decorate([
+    attr({ mode: 'boolean' })
+], GridProGenesisDatasource.prototype, "reverse", void 0);
+__decorate([
+    attr({ attribute: 'row-id' })
+], GridProGenesisDatasource.prototype, "rowId", void 0);
+GridProGenesisDatasource = __decorate([
+    customElement({
+        name: 'grid-pro-genesis-datasource',
+    })
+], GridProGenesisDatasource);
+export { GridProGenesisDatasource };

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

@@ -0,0 +1,2 @@
+export * from './grid-pro-genesis-datasource-next';
+export * from './grid-pro-genesis-datasource';