@genesislcap/grid-pro 15.20.2 → 15.21.1

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

@@ -525,8 +525,45 @@ export class GridProBaseDatasource extends GenesisGridDatasourceElement {
             changes: mappedTransaction,
         });
     }
-    applyTransaction(transaction) {
-        throw new Error('Method not implemented.');
+    /**
+     * Builds the index map used for server-side sorting from the resource's metadata.
+     * @remarks Real DATASERVER indexes keep their names; when the resource also (or only) reports
+     * SORTABLE_FIELDS - the synthetic bucket a req/rep resource uses for its sortable columns -
+     * those fields are merged in under the synthetic `SORTABLE_FIELDS` key. Note an index with no
+     * NAME lands under `undefined`: its fields count as indexed, but it cannot be named in an
+     * ORDER_BY, so sorting-related consumers must consider named entries only.
+     * @internal
+     */
+    getResourceIndexes(availableIndexes, availableSortableFields) {
+        const resourceIndexesMap = new Map();
+        const allSortableFields = new Set();
+        // Add indexes from INDEXES metadata
+        availableIndexes === null || availableIndexes === void 0 ? void 0 : availableIndexes.forEach((index) => {
+            const fields = index.FIELDS.split(' ');
+            resourceIndexesMap.set(index.NAME, fields);
+            fields.forEach((field) => allSortableFields.add(field));
+        });
+        // Add fields from SORTABLE_FIELDS metadata if available
+        if (availableSortableFields && availableSortableFields.length > 0) {
+            availableSortableFields.forEach((field) => allSortableFields.add(field));
+        }
+        // If we have SORTABLE_FIELDS but no indexes, create a synthetic index entry
+        if (resourceIndexesMap.size === 0 && allSortableFields.size > 0) {
+            resourceIndexesMap.set('SORTABLE_FIELDS', Array.from(allSortableFields));
+        }
+        else if (availableSortableFields &&
+            availableSortableFields.length > 0 &&
+            resourceIndexesMap.size > 0) {
+            const fieldsFromIndexes = new Set();
+            resourceIndexesMap.forEach((fields) => {
+                fields.forEach((field) => fieldsFromIndexes.add(field));
+            });
+            const additionalFields = availableSortableFields.filter((field) => !fieldsFromIndexes.has(field));
+            if (additionalFields.length > 0) {
+                resourceIndexesMap.set('SORTABLE_FIELDS', additionalFields);
+            }
+        }
+        return resourceIndexesMap;
     }
     /**
      * Maps the transaction data to the row data mapper function, if it exists.

package/dist/esm/datasource/filter.utils.js

@@ -0,0 +1,241 @@
+/**
+ * Shared filter utilities for converting AG Grid filter models to Genesis criteria strings.
+ * The single implementation of the filter-model grammar: the Infinite Row Model converts whole
+ * models through {@link convertFilterModelToCriteria}, and the Server-Side Row Model's
+ * `BaseServerSideDatasource.criteriaFor*Model` methods delegate to the per-type converters, so
+ * both row models send identical CRITERIA_MATCH for the same gesture.
+ * @beta
+ */
+/**
+ * Escapes a value for interpolation into a criteria string literal.
+ * @remarks Backslashes first, then quotes: an unescaped quote would end the literal early, and
+ * an unescaped trailing backslash (or a literal `\'` in the value) would escape the closing
+ * quote - either way the server rejects the whole expression.
+ */
+function escapeCriteriaValue(value) {
+    return String(value).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+/**
+ * Converts text filters to Genesis criteria strings.
+ * @param filterModel - The AG Grid filter model
+ * @param fieldName - The field name being filtered
+ * @returns Genesis criteria string or null
+ */
+export function convertTextFilterToCriteria(filterModel, fieldName) {
+    if (!filterModel.filter && (filterModel.type === 'false' || filterModel.type === 'true')) {
+        return `${fieldName} == ${filterModel.type}`;
+    }
+    const safeVal = filterModel.filter != null ? escapeCriteriaValue(filterModel.filter) : '';
+    switch (filterModel.type) {
+        case 'blank':
+            // Parenthesised: fragments are joined with ' && ', and && binds tighter than ||, so a
+            // bare `a == '' || a == null && b == 'x'` would let empty-a rows bypass b's filter.
+            return `(${fieldName} == '' || ${fieldName} == null)`;
+        case 'contains':
+            return `Expr.containsIgnoreCase(${fieldName}, '${safeVal}')`;
+        case 'equals':
+            return `${fieldName} == '${safeVal}'`;
+        case 'notBlank':
+            return `(${fieldName} != '' && ${fieldName} != null)`;
+        case 'notEqual':
+            return `${fieldName} != '${safeVal}'`;
+        case 'wordStartsWith':
+            return `Expr.containsWordsStartingWithIgnoreCase(${fieldName}, '${safeVal}')`;
+        default:
+            return null;
+    }
+}
+/**
+ * Converts set filters (for enum fields) to Genesis criteria strings.
+ * @param filterModel - The AG Grid filter model
+ * @param fieldName - The field name being filtered
+ * @param colMeta - Column metadata for detecting all values
+ * @returns Genesis criteria string or null
+ */
+export function convertSetFilterToCriteria(filterModel, fieldName, colMeta) {
+    var _a;
+    const selectedValues = ((_a = filterModel === null || filterModel === void 0 ? void 0 : filterModel.values) !== null && _a !== void 0 ? _a : []);
+    if (!selectedValues || selectedValues.length === 0) {
+        return null;
+    }
+    // Try to detect "all values selected" using VALID_VALUES from metadata.
+    // In that case we don't want to send any criteria, as it would be equivalent
+    // to no filter at all.
+    let allValues;
+    if (colMeta === null || colMeta === void 0 ? void 0 : colMeta.VALID_VALUES) {
+        try {
+            allValues = Array.isArray(colMeta.VALID_VALUES)
+                ? colMeta.VALID_VALUES
+                : colMeta.VALID_VALUES.split('|');
+        }
+        catch (_b) {
+            allValues = undefined;
+        }
+    }
+    if (allValues &&
+        allValues.length === selectedValues.length &&
+        allValues.every((v) => selectedValues.includes(v))) {
+        // All enum options are selected – skip adding criteria for this column
+        return null;
+    }
+    const orConditions = selectedValues.map((val) => {
+        return `${fieldName} == '${escapeCriteriaValue(val)}'`;
+    });
+    if (orConditions.length > 0) {
+        return `(${orConditions.join(' || ')})`;
+    }
+    return null;
+}
+/**
+ * Converts number filters to Genesis criteria strings.
+ * @param filterModel - The AG Grid filter model
+ * @param fieldName - The field name being filtered
+ * @returns Genesis criteria string or null
+ */
+export function convertNumberFilterToCriteria(filterModel, fieldName) {
+    const value = filterModel.filter;
+    const valueTwo = filterModel.filterTo;
+    // Not bare isNaN: isNaN(null) and isNaN('') are both false, so an absent value would be
+    // interpolated as-is and produce criteria the server rejects.
+    const isNum = (v) => v !== null && v !== '' && !isNaN(Number(v));
+    switch (filterModel.type) {
+        case 'equals':
+            return isNum(value) ? `${fieldName} == ${value}` : null;
+        case 'notEqual':
+            return isNum(value) ? `${fieldName} != ${value}` : null;
+        case 'greaterThan':
+            return isNum(value) ? `${fieldName} > ${value}` : null;
+        case 'greaterThanOrEqual':
+            return isNum(value) ? `${fieldName} >= ${value}` : null;
+        case 'lessThan':
+            return isNum(value) ? `${fieldName} < ${value}` : null;
+        case 'lessThanOrEqual':
+            return isNum(value) ? `${fieldName} <= ${value}` : null;
+        case 'inRange':
+            return isNum(value) && isNum(valueTwo)
+                ? `${fieldName} >= ${value} && ${fieldName} <= ${valueTwo}`
+                : null;
+        case 'blank':
+            // Blank means absent, not zero: a legitimate 0 must not report as blank, and a null
+            // value must. Matches the text and date converters.
+            return `${fieldName} == null`;
+        case 'notBlank':
+            return `${fieldName} != null`;
+        default:
+            return null;
+    }
+}
+/**
+ * Converts date filters to Genesis criteria strings.
+ * @param filterModel - The AG Grid filter model
+ * @param fieldName - The field name being filtered
+ * @returns Genesis criteria string or null
+ */
+export function convertDateFilterToCriteria(filterModel, fieldName) {
+    // AG Grid supplies bounds as '2026-09-02 00:00:00'; normalise to the 'yyyyMMdd' form the
+    // Expr.dateIs* helpers take. An absent bound yields no criteria rather than interpolating
+    // the string 'undefined' - reachable through setFilterModel, e.g. a restored filter config.
+    const normalise = (bound) => bound ? String(bound).replace(/-/g, '').replace('T', '-').split(' ')[0] : null;
+    const dateFrom = normalise(filterModel.dateFrom);
+    const dateTo = normalise(filterModel.dateTo);
+    switch (filterModel.type) {
+        case 'equals':
+            return dateFrom ? `Expr.dateIsEqual(${fieldName}, '${dateFrom}')` : null;
+        case 'lessThan':
+            return dateFrom ? `Expr.dateIsBefore(${fieldName}, '${dateFrom}')` : null;
+        case 'greaterThan':
+            return dateFrom ? `Expr.dateIsAfter(${fieldName}, '${dateFrom}')` : null;
+        case 'inRange':
+            return dateFrom && dateTo
+                ? `Expr.dateIsAfter(${fieldName}, '${dateFrom}') && Expr.dateIsBefore(${fieldName}, '${dateTo}')`
+                : null;
+        case 'isToday': {
+            // Same 'yyyyMMdd' shape as the normalised bounds above: 'equals' on today's date and
+            // 'isToday' must send identical criteria.
+            const now = new Date();
+            const month = (now.getMonth() + 1).toString().padStart(2, '0');
+            const day = now.getDate().toString().padStart(2, '0');
+            return `Expr.dateIsEqual(${fieldName}, '${now.getFullYear()}${month}${day}')`;
+        }
+        case 'blank':
+            return `${fieldName} == null`;
+        case 'notBlank':
+            return `${fieldName} != null`;
+        default:
+            return null;
+    }
+}
+/**
+ * Converts one flat filter model (or one multi-filter sub-model) to a criteria fragment.
+ * @param filter - The filter model
+ * @param fieldName - The field name being filtered
+ * @param colDefs - Column definitions for metadata (set filters)
+ * @returns Genesis criteria string or null
+ */
+function convertSingleFilterToCriteria(filter, fieldName, colDefs) {
+    switch (filter === null || filter === void 0 ? void 0 : filter.filterType) {
+        case 'text':
+            return convertTextFilterToCriteria(filter, fieldName);
+        case 'set': {
+            const colMeta = colDefs === null || colDefs === void 0 ? void 0 : colDefs.find((o) => o.NAME === fieldName);
+            return convertSetFilterToCriteria(filter, fieldName, colMeta);
+        }
+        case 'number':
+            return convertNumberFilterToCriteria(filter, fieldName);
+        case 'date':
+            return convertDateFilterToCriteria(filter, fieldName);
+        default:
+            return null;
+    }
+}
+/**
+ * Processes a single field's filter and returns its criteria fragment.
+ * @remarks Multi-filters ({ filterType: 'multi', filterModels: [...] }) are unwrapped honouring
+ * their `operator`: an OR multi-filter joins its sub-fragments with `||` and is parenthesised,
+ * so the outer ` && ` join between fields cannot rebind it.
+ * @param filterEntry - The filter entry for the field
+ * @param fieldName - The field name
+ * @param colDefs - Column definitions
+ * @returns The criteria fragment for the field, or null
+ */
+function processFieldFilter(filterEntry, fieldName, colDefs) {
+    if (!filterEntry)
+        return null;
+    if (filterEntry.filterType === 'multi' && Array.isArray(filterEntry.filterModels)) {
+        const operator = (filterEntry.operator || 'AND').toUpperCase();
+        const joiner = operator === 'OR' ? ' || ' : ' && ';
+        const fragments = filterEntry.filterModels
+            .map((subModel) => convertSingleFilterToCriteria(subModel, fieldName, colDefs))
+            .filter((fragment) => Boolean(fragment));
+        if (fragments.length === 0)
+            return null;
+        return fragments.length === 1 ? fragments[0] : `(${fragments.join(joiner)})`;
+    }
+    return convertSingleFilterToCriteria(filterEntry, fieldName, colDefs);
+}
+/**
+ * Converts AG Grid filter model to Genesis criteria string.
+ * This is the main entry point for converting filters.
+ * Handles both simple filters and multi-filters (filterType: "multi" with filterModels array).
+ * @param filterModel - The AG Grid filter model
+ * @param colDefs - Column definitions for metadata (optional but recommended)
+ * @returns Genesis criteria string
+ */
+export function convertFilterModelToCriteria(filterModel, colDefs) {
+    if (!filterModel || Object.keys(filterModel).length === 0) {
+        return '';
+    }
+    const filters = [];
+    // Process each field in the filter model
+    for (const fieldName of Object.keys(filterModel)) {
+        // Skip if column not in colDefs (when colDefs provided)
+        if (colDefs && colDefs.findIndex((o) => o.NAME === fieldName) === -1) {
+            continue;
+        }
+        const fieldCriteria = processFieldFilter(filterModel[fieldName], fieldName, colDefs);
+        if (fieldCriteria) {
+            filters.push(fieldCriteria);
+        }
+    }
+    return filters.join(' && ');
+}

package/dist/esm/datasource/index.js

@@ -3,6 +3,8 @@ export * from './base.types';
 export * from './client-side.datasource';
 export * from './error-handler.dialog';
 export * from './datasource.types';
+export * from './filter.utils';
+export * from './infinite.datasource';
 export * from './row-match.types';
 export * from './row-match.tracker';
 export * from './row-match.classes';

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

@@ -0,0 +1,373 @@
+import { __awaiter, __decorate } from "tslib";
+import { Connect, ConnectEvents, Datasource, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
+import { LifecycleMixin } from '@genesislcap/foundation-utils';
+import { customElement, DOM, observable } from '@microsoft/fast-element';
+import { gridProGenesisDatasourceEventNames } from '../grid-pro-genesis-datasource';
+import { datasourceEventNames, } from '../grid-pro-genesis-datasource/datasource-events.types';
+import { logger } from '../utils';
+import { GridProBaseDatasource } from './base.datasource';
+import { GenesisInfiniteDatasource } from './infinite.resource';
+import { getFilterByFieldType, getServerSideFilterParamsByFieldType, } from './server-side.grid-definitions';
+const criteriaDelimiter = ';';
+/**
+ * A Genesis Datasource element for AG Grid's Infinite Row Model.
+ * @remarks
+ * The Infinite Row Model is part of AG Grid Community (free) and provides:
+ * - Lazy loading of data as user scrolls
+ * - Server-side sorting and filtering
+ * - Simple infinite scroll without grouping/aggregation
+ * - Live updates for DATASERVER resources: the DATA_LOGON stream the grid pages over pushes
+ *   every change, so no flag or second subscription is needed
+ *
+ * REQUEST_SERVER resources are read on demand only - a change on the server shows up when the
+ * grid re-reads (scroll, filter/sort change, or an explicit refresh), not live. The exception
+ * is a write made through this session: a commit ACK for an event listed in `pollTriggerEvents`
+ * re-reads the loaded blocks, so entity-management CRUD is reflected immediately.
+ *
+ * Unlike the other datasources, this element deliberately does not consume `deferredGridOptions`
+ * (the mechanism is being retired): grid options set there - including via entity-management's
+ * `gridOptions` with `datasource-type="infinite"` - are not applied. Set options on the grid
+ * element itself instead.
+ *
+ * Use this instead of Server-Side Row Model when you don't need Enterprise features
+ * like row grouping, aggregation, or pivoting.
+ *
+ * @see https://www.ag-grid.com/javascript-data-grid/infinite-scrolling/
+ * @beta
+ *
+ * @fires base-datasource-error - Fired when a datasource error is reported. detail: `BaseDatasourceErrorEventDetail`
+ * @fires datasource-error - Fired when a datasource error occurs (for grid integration). detail: `DatasourceErrorEventDetail`
+ * @fires base-datasource-connected - Fired when error state is cleared after connection succeeds
+ * @fires datasource-initialize - Fired to hand off infinite row model grid options. detail: `InitializeEventDetail`
+ * @fires datasource-init - Fired when the infinite grid model should initialize data
+ * @fires datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`
+ * @fires set-infinite-datasource - Fired to attach or clear the infinite row model datasource. detail: `SetInfiniteDatasourceEventDetail`
+ * @fires refresh-infinite-cache - Fired to request an infinite row model refresh; `purge` drops the block cache and re-reads. detail: `RefreshInfiniteCacheEventDetail`
+ * @fires cache-filter-config - Fired to persist filter configuration for the grid
+ * @fires datasource-data-cleared - Fired when infinite row data is cleared. detail: `DataClearedEventDetail`
+ * @fires datasource-filters-restored - Fired when persisted filters are reapplied
+ */
+let GridProInfiniteDatasource = class GridProInfiniteDatasource extends LifecycleMixin(GridProBaseDatasource) {
+    constructor() {
+        super(...arguments);
+        this.request = {};
+        /** @internal */
+        this.onDatasourceReady = (_event) => __awaiter(this, void 0, void 0, function* () {
+            const initOK = yield this.initializeDatasource(this.datasourceOptions(), true, false);
+            if (!initOK) {
+                logger.debug(`Genesis Datasource init failed for ${this.resourceName}`);
+                this.clearRowData();
+                this.setDisconnected(true);
+                return;
+            }
+            this.$emit(gridProGenesisDatasourceEventNames.dataInit);
+            this.setDisconnected(false);
+            this.indexes = this.getResourceIndexes(this.datasource.availableIndexes, this.datasource.availableSortableFields);
+            const fieldMetadata = toFieldMetadata(this.datasource.originalFieldDef);
+            const agColumnDefs = yield this.getAgColumnDefs(fieldMetadata);
+            // Emit event to set column definitions
+            this.$emit(datasourceEventNames.schemaUpdated, {
+                schema: agColumnDefs,
+                metadata: fieldMetadata,
+            });
+            // Create the infinite datasource
+            this.infiniteDatasource = new GenesisInfiniteDatasource({
+                createSnapshotFunc: this.createSnapshot.bind(this),
+                createDataserverStreamFunc: this.createDataserverStream.bind(this),
+                // VIEW_NUMBER 0 means "pagination disabled": the server continues from the cursor it
+                // holds on the last row it delivered, rather than re-seeking by offset.
+                getMoreRowsFunc: (sourceRef) => this.connect.getMoreRows(sourceRef, 0),
+                // A pushed INSERT/DELETE changes which rows exist or their order, so the rows are
+                // re-read (purge); a pushed MODIFY is already patched into the cache, so the grid only
+                // needs to re-render its blocks.
+                onRowsInvalidatedFunc: () => this.$emit(datasourceEventNames.refreshInfiniteCache, {
+                    purge: true,
+                }),
+                onRowsUpdatedFunc: () => this.$emit(datasourceEventNames.refreshInfiniteCache, {
+                    purge: false,
+                }),
+                errorHandlerFunc: this.handleErrors.bind(this),
+                resourceName: this.resourceName,
+                resourceParams: this.isRequestServer
+                    ? this.datasource.requestOnlyParams
+                    : this.datasource.dataserverOnlyParams,
+                resourceIndexes: this.indexes,
+                resourceColDefs: this.datasource.originalFieldDef,
+                maxRows: +this.maxRows,
+                rowId: this.rowId,
+                baseCriteria: this.criteria,
+                isRequestServer: this.isRequestServer,
+            });
+            // Emit event to set infinite datasource
+            this.$emit(datasourceEventNames.setInfiniteDatasource, {
+                datasource: this.infiniteDatasource,
+            });
+            // DATASERVER needs no live-update setup: it is live through the paging DATA_LOGON stream
+            // itself (GenesisInfiniteDatasource reports pushes via onRowsInvalidated/onRowsUpdated).
+            // REQUEST_SERVER is read on demand, but a write committed through this session should not
+            // wait for the user to scroll or reload:
+            this.setupCommitTriggeredRefresh();
+            // Emit event to restore cached filter config
+            this.$emit(datasourceEventNames.filtersRestored);
+        });
+    }
+    resourceNameChanged(oldValue, newValue) {
+        if (!oldValue || oldValue === newValue)
+            return;
+        DOM.queueUpdate(() => __awaiter(this, void 0, void 0, function* () {
+            yield this.restart();
+        }));
+    }
+    criteriaChanged(oldCriteria, newCriteria) {
+        const criteriaIsNotDuplicate = oldCriteria !== normaliseCriteria(newCriteria, criteriaDelimiter);
+        if (this.infiniteDatasource && criteriaIsNotDuplicate) {
+            DOM.queueUpdate(() => __awaiter(this, void 0, void 0, function* () {
+                yield this.reloadResourceData();
+            }));
+        }
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        const shouldRunConnect = this.shouldRunConnect;
+        DOM.queueUpdate(() => {
+            if (!shouldRunConnect)
+                return;
+            this.init();
+            this.subscribeToConnection();
+        });
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        const shouldRunDisconnect = this.shouldRunDisconnect;
+        DOM.queueUpdate(() => __awaiter(this, void 0, void 0, function* () {
+            if (!shouldRunDisconnect)
+                return;
+            yield this.destroy();
+            this.unsubscribeFromConnection();
+        }));
+    }
+    deepClone() {
+        const copy = super.deepClone();
+        copy.deferredColumnStates = structuredClone(this.deferredColumnStates);
+        return copy;
+    }
+    /**
+     * Resets the grid data while keeping columnDefs and reloads data.
+     * @remarks This is used when the grid is already initialized and we want to reload the data due to a criteria/filter change.
+     * @beta
+     */
+    reloadResourceData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // The paging DATA_LOGON is opened through connect.stream, not this.datasource, so destroying
+            // the comms datasource below does not close it. Dispose the IDatasource explicitly or every
+            // criteria change (e.g. a bound search box) leaks a live subscription and its block timers.
+            (_b = (_a = this.infiniteDatasource) === null || _a === void 0 ? void 0 : _a.destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+            this.infiniteDatasource = undefined;
+            this.datasource.destroy();
+            // Emit event to cache current filter model before clearing data
+            this.$emit(datasourceEventNames.cacheFilterConfig);
+            this.clearRowData(false);
+            this.setDisconnected(false);
+            // Purge the infinite cache (clears all data and refetches)
+            this.$emit(datasourceEventNames.refreshInfiniteCache, {
+                purge: true,
+            });
+            yield this.init();
+        });
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Emit event to initialize grid with infinite row model options
+            const gridOptions = {
+                getRowId: (params) => {
+                    if (!params.data) {
+                        return null;
+                    }
+                    return String(params.data[this.rowId]);
+                },
+                cacheBlockSize: this.maxRows,
+                defaultColDef: {
+                    filter: true,
+                    resizable: true,
+                    // Off by default, like the SSRM options: getAgColumnDefs opts individual columns in, so
+                    // columns from other sources (grid-pro-column templates, entity-management's action
+                    // column) don't render a sort control the server cannot honour.
+                    sortable: false,
+                    unSortIcon: true,
+                },
+                rowBuffer: 0,
+                rowModelType: 'infinite',
+                // convertSortModelToOrderBy reads only sortModel[0], so a multi-sort's extra columns
+                // would paint indicators whose direction is silently discarded.
+                suppressMultiSort: true,
+                // Infinite Row Model specific options
+                cacheOverflowSize: 2,
+                maxConcurrentDatasourceRequests: 1,
+                infiniteInitialRowCount: 1,
+                maxBlocksInCache: 10,
+            };
+            this.$emit(datasourceEventNames.initialize, {
+                options: gridOptions,
+                keepColDefsOnClearRowData: this.keepColDefsOnClearRowData,
+            });
+            // Listen for grid ready event. Clear any listener a previous init() left pending first:
+            // two quick criteria changes would otherwise stack two once-listeners, and the single
+            // ready event would then run the whole initialization twice.
+            this.clearReadyListener();
+            this.addEventListener(datasourceEventNames.ready, this.onDatasourceReady, {
+                once: true,
+            });
+            if (!this.resourceName) {
+                this.handleErrors('Application not connected or invalid resource name, datasource will not work.', 'unknown');
+            }
+        });
+    }
+    /** @internal */
+    clearReadyListener() {
+        this.removeEventListener(datasourceEventNames.ready, this.onDatasourceReady);
+    }
+    destroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // A ready event arriving after teardown must not re-run the initialization.
+            this.clearReadyListener();
+            this.teardownCommitTriggeredRefresh();
+            this.datasource.destroy();
+            this.clearRowData();
+            if (this.infiniteDatasource) {
+                (_b = (_a = this.infiniteDatasource).destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+                this.infiniteDatasource = undefined;
+            }
+            // Emit events instead of direct grid access
+            this.$emit(datasourceEventNames.setInfiniteDatasource, {
+                datasource: null,
+            });
+        });
+    }
+    restart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.destroy();
+            yield this.init();
+        });
+    }
+    clearRowData(withColumnDefs = true) {
+        this.rowData = new Map();
+        if (withColumnDefs) {
+            // Emit event to clear column definitions
+            this.$emit(datasourceEventNames.dataCleared, {
+                includeSchema: true,
+            });
+        }
+        this.transactionData = { remove: [] };
+    }
+    /**
+     * Honours `pollTriggerEvents` without polling: a commit ACK for one of the listed events
+     * means a write went through this session, so the loaded blocks are re-read in place - the
+     * same action as `applyTransaction`, which keeps the grid's row count and scroll position.
+     * @remarks REQUEST_SERVER only. DATASERVER already receives every change on the paging
+     * subscription, so a commit-triggered re-read there would just duplicate the live push.
+     * @internal
+     */
+    setupCommitTriggeredRefresh() {
+        var _a;
+        this.teardownCommitTriggeredRefresh();
+        if (this.isSnapshot || !this.isRequestServer || !((_a = this.pollTriggerEvents) === null || _a === void 0 ? void 0 : _a.length)) {
+            return;
+        }
+        this.commitResponseUnsubscribe = this.connectEvents.addCommitResponseListener((event) => {
+            var _a;
+            const { eventName, response } = event.detail;
+            if (this.pollTriggerEvents.includes(eventName) && ((_a = response.MESSAGE_TYPE) === null || _a === void 0 ? void 0 : _a.endsWith('_ACK'))) {
+                logger.debug(`Commit ACK for ${eventName}, re-reading the loaded blocks.`);
+                this.$emit(datasourceEventNames.refreshInfiniteCache, {
+                    purge: false,
+                });
+            }
+        });
+    }
+    /** Safe to call when the listener was never registered. @internal */
+    teardownCommitTriggeredRefresh() {
+        var _a;
+        (_a = this.commitResponseUnsubscribe) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.commitResponseUnsubscribe = undefined;
+    }
+    /**
+     * Creates a snapshot request to the server.
+     * @param existingParams - Optional existing parameters to include
+     * @returns The server response
+     */
+    createSnapshot() {
+        return __awaiter(this, arguments, void 0, function* (existingParams = null) {
+            const result = yield this.datasource.snapshot(existingParams);
+            return result;
+        });
+    }
+    /**
+     * Opens the paged DATASERVER subscription used to serve grid blocks.
+     * @remarks Deliberately a stream and not a snapshot: paging is a MORE_ROWS request against a
+     * live subscription, and a fresh DATA_LOGON would always come back with page 1.
+     * @internal
+     */
+    createDataserverStream(params = null) {
+        const onError = (error) => {
+            var _a;
+            logger.error('Infinite DATASERVER paged stream error:', error);
+            this.handleErrors(((_a = error === null || error === void 0 ? void 0 : error.receivedMessage) === null || _a === void 0 ? void 0 : _a.ERROR) || (error === null || error === void 0 ? void 0 : error.message), 'stream');
+        };
+        return this.connect.stream(this.resourceName, () => { }, onError, params);
+    }
+    getAgColumnDefs(fieldsMetadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The same filter mapping as the server-side row model, enums included: enum columns ask
+            // for agSetColumnFilter, and the grid swaps in the community text filter when the app has
+            // not registered the Enterprise SetFilterModule (see processSchemaUpdate in grid-pro-beta).
+            const colDefsFromGenesisData = this.generateColumnDefsFromMetadata(fieldsMetadata, getServerSideFilterParamsByFieldType, getFilterByFieldType);
+            // Sortability differs by transport, matching convertSortModelToOrderBy:
+            // - REQUEST_SERVER orders any column (direction inline), so every column is sortable.
+            // - DATASERVER can only ORDER_BY a NAMED index, so a column is sortable only when it belongs
+            //   to one. An unnamed index (stored under an undefined key) cannot be named, so its columns
+            //   would render a sort control convertSortModelToOrderBy then drops - excluded here.
+            const namedIndexFields = new Set();
+            this.indexes.forEach((fields, indexName) => {
+                if (indexName) {
+                    fields.forEach((field) => namedIndexFields.add(field));
+                }
+            });
+            colDefsFromGenesisData.forEach((colDef) => {
+                colDef.sortable = this.isRequestServer || namedIndexFields.has(colDef.field);
+                // A criteria-only req/rep accepts CRITERIA_MATCH on its declared criteria fields only;
+                // filtering any other column would send criteria the server rejects, which on this row
+                // model fails the block rather than surfacing a filter error.
+                if (this.datasource.criteriaOnlyRequest) {
+                    colDef.filter = this.datasource.availableCriteriaFields.includes(colDef.field)
+                        ? colDef.filter
+                        : null;
+                }
+            });
+            return colDefsFromGenesisData;
+        });
+    }
+    loadMore() {
+        // Infinite row model handles this automatically via scrolling
+        logger.warn('loadMore() is not needed for Infinite Row Model - scrolling triggers data loading automatically');
+    }
+};
+__decorate([
+    Connect
+], GridProInfiniteDatasource.prototype, "connect", void 0);
+__decorate([
+    ConnectEvents
+], GridProInfiniteDatasource.prototype, "connectEvents", void 0);
+__decorate([
+    Datasource
+], GridProInfiniteDatasource.prototype, "datasource", void 0);
+__decorate([
+    observable
+], GridProInfiniteDatasource.prototype, "request", void 0);
+GridProInfiniteDatasource = __decorate([
+    customElement({
+        name: 'grid-pro-infinite-datasource',
+    })
+], GridProInfiniteDatasource);
+export { GridProInfiniteDatasource };