@genesislcap/grid-pro 15.30.0 → 15.30.2

package/dist/grid-pro.d.ts

@@ -721,7 +721,8 @@ export declare type ColumnPickerSort = 'selected-first' | 'ag-grid';
  * Layout: select-all + search → column list. Ordering via `sort`
  * (`selected-first` default, or `ag-grid`). Checkboxes toggle visibility via
  * `api.setColumnsVisible`; drag handles on hidden rows use AG native DnD onto the grid
- * (`allowDragFromColumnsToolPanel`); visible rows reorder inside the picker via HTML5 drag.
+ * (`allowDragFromColumnsToolPanel`) even while search is active; visible-row reorder inside
+ * the picker uses HTML5 drag and is disabled during search.
  *
  * @tagname %%prefix%%-column-selection
  */
@@ -775,8 +776,8 @@ export declare class ColumnSelection extends ColumnSelection_base {
     private set pickerApi(value);
     /** Query root for picker DOM (shadow panel). */
     private get pickerRoot();
-    /** Drag reorder / grid drop disabled while search filter is active. */
-    get canDrag(): boolean;
+    /** Panel reorder disabled while search filter is active. */
+    get canReorderInPanel(): boolean;
     /** Handle is draggable onto the grid (hidden columns, or all when using ag-grid sort). */
     canDragToGrid(item: ColumnPickerItem): boolean;
     /** Columns in the current (search-filtered) picker lists that can be toggled. */
@@ -1430,8 +1431,12 @@ export declare const csvExportParams: CsvExportParams;
 export declare interface DataChangedEventDetail {
     changes: {
         add?: any[];
+        /** Row-id-only objects (`{ [rowId]: id }`) for the rows that left the grid. */
         remove?: any[];
         update?: any[];
+        /** Where `add` rows were inserted, as AG Grid's `RowDataTransaction.addIndex`. */
+        addIndex?: number;
+        /** @deprecated Never populated; the emitted field is `addIndex`. */
         insertIndex?: number;
     };
 }
@@ -2562,7 +2567,12 @@ export declare class GenesisGridDatasourceElement extends GenesisGridDatasourceE
     protected criteriaFromFilters: Map<string, string>;
     protected update: BehaviorSubject<Map<string, string>>;
     protected datasourceOptions(): DatasourceOptions;
-    private buildCriteria;
+    /**
+     * The criteria the resource should be read with: the `criteria` attribute plus anything added
+     * through `setFilter()`.
+     * @internal
+     */
+    protected buildCriteria(): string;
     setFilter(fieldName: string, newFilter: string): void;
     removeFilter(fieldName: string): void;
     get isRequestServer(): boolean;
@@ -2623,12 +2633,7 @@ declare const GenesisGridDatasourceElement_base: new () => {
     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options
-    /**
-    * Optional parameter that allows you to select a subset of fields from the query if the client is not interested in receiving all of them.
-    * @remarks DATASERVER only.
-    */
-    ?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     readonly attributes: NamedNodeMap;
     get classList(): DOMTokenList;
     set classList(value: string): any;
@@ -2693,7 +2698,15 @@ declare const GenesisGridDatasourceElement_base: new () => {
     removeAttribute(qualifiedName: string): void;
     removeAttributeNS(namespace: string | null, localName: string): void;
     removeAttributeNode(attr: Attr): Attr;
-    requestFullscreen(options?: FullscreenOptions): Promise<void>;
+    requestFullscreen(options
+    /**
+    * Returns whether the `row-id` attribute is the default one, depending on the resource type.
+    * @internal
+    */
+    ? /**
+    * Returns whether the `row-id` attribute is the default one, depending on the resource type.
+    * @internal
+    */: FullscreenOptions): Promise<void>;
     requestPointerLock(options?: PointerLockOptions): Promise<void>;
     scroll(options?: ScrollToOptions): void;
     scroll(x: number, y: number): void;
@@ -2967,6 +2980,15 @@ declare class GenesisInfiniteDatasource implements IDatasource {
     private rowId;
     private baseCriteria;
     private isRequestServer;
+    /**
+     * The `order-by` attribute, used when the grid itself is unsorted.
+     * @remarks DATASERVER takes the name of an index on the query; REQUEST_SERVER takes a column
+     * with the direction inline.
+     * @internal
+     */
+    private defaultOrderBy?;
+    /** The `reverse` attribute, applied alongside `defaultOrderBy` on DATASERVER. @internal */
+    private defaultReverse;
     private createSnapshotFunc;
     private createDataserverStreamFunc;
     private getMoreRowsFunc;
@@ -2974,17 +2996,69 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * Called when an unsolicited batch changes which rows exist or their order (an INSERT or a
      * DELETE). The cache cannot be patched in place for those - a created row arrives at the end
      * rather than in sort position, and a delete below the delivered watermark is skipped to keep
-     * slice offsets stable - so the rows have to be re-read.
+     * slice offsets stable - so the rows have to be re-read. Receives the pushed change so the
+     * host can report it before the re-read.
      * @internal
      */
     private onRowsInvalidatedFunc?;
     /**
      * Called when an unsolicited batch only modified rows already held. The cache is patched in
-     * place, so the grid just needs to re-render its blocks.
+     * place, so the grid just needs to re-render its blocks. Receives the pushed change so the
+     * host can report it.
      * @internal
      */
     private onRowsUpdatedFunc?;
+    /**
+     * Called with the rows just handed to AG Grid for a block, on either transport. This is the
+     * only point at which rows leave the datasource, so it is where the host learns which rows
+     * the grid holds (a re-read after a refresh delivers the same rows again).
+     * @internal
+     */
+    private onRowsDeliveredFunc?;
+    /**
+     * Called with the ids of rows a re-read of a block no longer returned: they left the grid
+     * (deleted on the server, or moved into a block that reports them again).
+     * @internal
+     */
+    private onRowsWithdrawnFunc?;
+    /**
+     * Called when a filter or sort change drops every row the grid held, on either transport, so
+     * the host forgets them too. AG Grid purges its own cache on those changes.
+     * @internal
+     */
+    private onRowCacheResetFunc?;
+    /**
+     * Called when the first block comes back with no rows, and when it comes back with rows, so
+     * the host can raise the same no-data / loading-finished events the server-side model does.
+     * @internal
+     */
+    private onNoDataAvailableFunc?;
+    /** @internal */
+    private onDataAvailableFunc?;
     private errorHandlerFunc;
+    /** Which rows each delivered block carried, for withdrawal and eviction reporting. @internal */
+    private ledger;
+    /**
+     * Bumped whenever the rows this datasource was reading for are dropped (a teardown, or a
+     * filter/sort change). A REQUEST_SERVER reply that resolves for an earlier generation was read
+     * for a cache the grid no longer has.
+     * @remarks Deliberately a generation rather than a "destroyed" flag: AG Grid calls `destroy()`
+     * on the datasource bean it then keeps using (`InfiniteRowModel.start()` re-applies the
+     * `datasource` grid option, and `setDatasource` destroys the previous one first), so a sticky
+     * flag would disable the instance the grid is still driving.
+     * @internal
+     */
+    private loadGeneration;
+    /**
+     * Set once the host has dropped this instance for a replacement (a criteria change, a resource
+     * change, teardown). AG Grid keeps calling the bean it was given until the new one is attached,
+     * and its purge re-requests blocks immediately, so without this the replaced instance keeps
+     * reading with its captured criteria and reporting those rows to the host as delivered.
+     * @remarks Distinct from `destroy()`, which AG Grid itself calls on a bean it then keeps using;
+     * only the host calls `detach()`, and only when it will never use this instance again.
+     * @internal
+     */
+    private detached;
     /**
      * Max time a DATASERVER block may stay pending before the safety valve resolves it with the
      * rows accumulated so far.
@@ -3007,11 +3081,20 @@ declare class GenesisInfiniteDatasource implements IDatasource {
     private dataserverStreamSubscription;
     private sourceRef;
     /**
-     * Identifies the CRITERIA_MATCH/ORDER_BY the current subscription was opened with; a change
-     * means the subscription has to be re-opened, as those are DATA_LOGON parameters.
+     * Identifies the CRITERIA_MATCH/ORDER_BY the current rows were read with. A change means AG
+     * Grid has dropped every block (it purges on filter/sort changes): on DATASERVER the
+     * subscription has to be re-opened, as those are DATA_LOGON parameters, and on both transports
+     * the host is told its held rows are gone.
      * @internal
      */
     private subscriptionKey;
+    /**
+     * Identifies the CRITERIA_MATCH/ORDER_BY the rows the host currently holds were read with.
+     * Unlike `subscriptionKey` this survives a subscription teardown, so a filter or sort change
+     * is still recognised as one when a live push tore the subscription down first.
+     * @internal
+     */
+    private rowCacheKey;
     /**
      * Session-cumulative row cache, keyed by row id. A Map preserves insertion order, so the
      * cache can be sliced by block range; Genesis splits batches across messages and later
@@ -3046,8 +3129,11 @@ declare class GenesisInfiniteDatasource implements IDatasource {
         createSnapshotFunc: (params?: any) => Promise<RequestServerResult | FilteredDataServerResult>;
         createDataserverStreamFunc?: (params?: any) => SocketObservable<FilteredDataServerResult>;
         getMoreRowsFunc?: (sourceRef: string) => Promise<unknown>;
-        onRowsInvalidatedFunc?: () => void;
-        onRowsUpdatedFunc?: () => void;
+        onRowsInvalidatedFunc?: (change: FilteredDataServerResult) => void;
+        onRowsUpdatedFunc?: (change: FilteredDataServerResult) => void;
+        onRowsDeliveredFunc?: (rows: any[]) => void;
+        onRowsWithdrawnFunc?: (rowIds: string[]) => void;
+        onRowCacheResetFunc?: () => void;
         errorHandlerFunc: (message: string, type: string) => void;
         resourceName: string;
         resourceParams: any;
@@ -3057,6 +3143,10 @@ declare class GenesisInfiniteDatasource implements IDatasource {
         rowId: string;
         baseCriteria?: string;
         isRequestServer: boolean;
+        defaultOrderBy?: string;
+        defaultReverse?: boolean;
+        onNoDataAvailableFunc?: () => void;
+        onDataAvailableFunc?: () => void;
     });
     /**
      * Builds request parameters for REQUEST_SERVER resources.
@@ -3090,6 +3180,23 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * outstanding at once, and each settles as soon as the cache covers its range.
      * @internal
      */
+    /**
+     * Notes the CRITERIA_MATCH/ORDER_BY a block is being read with. A change means AG Grid has
+     * purged its cache and restarted from block 0: on DATASERVER the subscription is re-opened
+     * (those are DATA_LOGON parameters), and on both transports the host is told the rows it held
+     * are gone, so the rows read under the new filter or sort are reported as new.
+     * @internal
+     */
+    /**
+     * The sort a block is read with: the grid's own sort model when the user has sorted, and the
+     * `order-by` / `reverse` attributes otherwise.
+     * @remarks Without the fallback those attributes reached the comms datasource but were then
+     * dropped, because the logon builder removes ORDER_BY and REVERSE whenever the grid is
+     * unsorted. Sorting from the grid still wins, as it is the more specific instruction.
+     * @internal
+     */
+    private resolveSortConfig;
+    private noteRequestKey;
     private getDataserverRows;
     /**
      * Keeps pulling batches while blocks are still waiting.
@@ -3138,6 +3245,19 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * @internal
      */
     private settleBlock;
+    /**
+     * Raises the no-data / data-available hooks for the first block, as the server-side resource
+     * does. Later blocks say nothing: the question is whether the resource has any rows at all,
+     * and the answer cannot change once the first block has been served.
+     * @internal
+     */
+    private notifyDataAvailability;
+    /**
+     * Reports rows handed to the grid for a block, then the rows a re-read of that block no longer
+     * carries and the rows whose block the grid evicted.
+     * @internal
+     */
+    private deliverRows;
     /**
      * Warns when the view filled up before the data ran out.
      * @remarks The server stops sending at MAX_VIEW rows and reports MORE_ROWS false, which is
@@ -3163,7 +3283,23 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * @internal
      */
     private teardownDataserverSubscription;
+    /**
+     * Drops the subscription and the cached rows.
+     * @remarks AG Grid calls this on the bean it then keeps using (`InfiniteRowModel.start()`
+     * re-applies the `datasource` grid option, and `setDatasource` destroys the previous one
+     * first), and it can land while a block request is in flight. So it must leave the datasource
+     * able to serve that reply and the next `getRows`: it drops the subscription, not the instance.
+     */
     destroy?(): void;
+    /**
+     * Drops this instance for good: the host is replacing it, so it must stop serving the grid and
+     * stop reporting rows, even though AG Grid still holds it as its `datasource` until the
+     * replacement is attached.
+     * @remarks Deliberately separate from `destroy()`, which AG Grid calls on a bean it then keeps
+     * using (`InfiniteRowModel.start()` re-applies the `datasource` grid option, and `setDatasource`
+     * destroys the previous one first).
+     */
+    detach(): void;
 }
 
 /**
@@ -4243,19 +4379,71 @@ declare const GridPro_base: (new (...args: any[]) => {
 }) & typeof FoundationElement;
 
 export declare class GridProBaseDatasource extends GenesisGridDatasourceElement {
+    serializer: JSONSerializer;
     protected dataSubWasLoggedOff: boolean;
     keepColDefsOnClearRowData: boolean;
     rowData: Map<string, any>;
     protected transactionData: TransactionData;
+    /** So rows without a row id are warned about once per element, not once per block. @internal */
+    private missingRowIdWarned;
     protected connectionSub: Subscription | undefined;
     protected subscribeToConnection(): void;
     protected unsubscribeFromConnection(): void;
     protected generateColumnDefsFromMetadata(fieldsMetadata: FieldMetadata[], getFilterParamsByFieldType: (field: FieldMetadata) => ColDef['filterParams'] | any, getFilterByFieldType: (type: FieldTypeEnum) => string): ColDef[];
     protected handleStreamInserts(insertedRows: any[], addIndex?: number): void;
+    /**
+     * Resolves the id of the held row a stream row refers to.
+     * @remarks Under a custom `row-id` a DATASERVER push may carry only the default id
+     * (`ROW_REF`), so the held row with that default id supplies the custom one. Returns
+     * `undefined` when neither id is present - callers skip the row rather than matching
+     * `undefined === undefined` against the first held row.
+     * @internal
+     */
+    protected resolveRowId(row: any): string | undefined;
     protected handleStreamDeletes(deletedRows: any[]): void;
     protected handleStreamUpdates(updatedRows: any[]): void;
     protected applyAllTransactions(): void;
     private applyMappedTransaction;
+    /**
+     * Reports rows a block-based row model (server-side, infinite) has just handed to the grid.
+     * Rows not held before are reported as `add`; rows already held (a block re-read after a
+     * refresh, or a req/rep re-read after a commit or poll) are reported as `update` only when
+     * their content changed, so a plain re-read is silent.
+     * @remarks `rowData` holds the rows delivered since the last cache reset: the resource reports
+     * rows a re-read no longer returned (`reportWithdrawnRows`), and `clearRowData` empties it when
+     * the grid drops its cache. Block eviction is not mirrored - see `DeliveredBlockLedger` - so
+     * this is a superset of what the grid holds.
+     * @internal
+     */
+    protected reportDeliveredRows(rows: any[]): void;
+    /**
+     * Reports rows a block re-read no longer returned: they left the grid (deleted on the server,
+     * or moved into a block that reports them again). Rows already reported removed - a DATASERVER
+     * push, say - are skipped.
+     * @internal
+     */
+    protected reportWithdrawnRows(rowIds: string[]): void;
+    /**
+     * Starts a fresh transaction and returns it, so a caller can keep working on the object it
+     * built even if a consumer's `datasource-data-changed` handler resets the element meanwhile.
+     * @internal
+     */
+    protected resetTransaction(): TransactionData & {
+        add: any[];
+        remove: any[];
+        update: any[];
+    };
+    /**
+     * Whether two versions of a row differ in content. Identity and a key-order-insensitive
+     * field comparison come first, so a re-read of unchanged rows costs no serialization; nested
+     * values fall back to the serializer.
+     * @internal
+     */
+    protected hasRowContentChanged(known: any, row: any): boolean;
+    /** Emits `datasource-data-changed` for `transaction` when it is non-empty. @internal */
+    protected emitTransaction(transaction: TransactionData | undefined): void;
+    /** @internal */
+    private warnMissingRowIdOnce;
     /**
      * 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
@@ -4511,6 +4699,12 @@ export declare class GridProBeta extends GridProBeta_base {
      * @internal
      */
     private handleDataChanged;
+    /**
+     * Whether the live grid runs AG Grid's client-side row model (the default when the datasource
+     * set no `rowModelType`).
+     * @internal
+     */
+    private get isClientSideRowModel();
     private flashAddedCells;
     /**
      * Handles schema updates from datasource
@@ -6431,12 +6625,15 @@ export declare const gridProGenesisDatasourceEventNames: {
  * @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 datasource-data-changed - Fired when rows are delivered to the grid, a DATASERVER push changes them, or a re-read no longer returns them; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`
  * @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 add-grid-css-class - Fired to add a CSS class on the grid host (hover sort indicators). detail: `GridCssClassEventDetail`
  * @fires remove-grid-css-class - Fired to remove that CSS class from the grid host. detail: `GridCssClassEventDetail`
  * @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-data-cleared - Fired when the grid drops every row it held (reload, filter or sort change, destroy); `includeSchema` says whether the columns went too. detail: `DataClearedEventDetail`
+ * @fires datasource-loading-finished - Fired when the first block comes back with rows
+ * @fires datasource-no-data-available - Fired when the first block comes back empty
  * @fires datasource-filters-restored - Fired when persisted filters are reapplied
  */
 export declare class GridProInfiniteDatasource extends GridProInfiniteDatasource_base {
@@ -6452,6 +6649,19 @@ export declare class GridProInfiniteDatasource extends GridProInfiniteDatasource
     criteriaChanged(oldCriteria: string, newCriteria: string): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    /** Unsubscribes the `setFilter()` listener. @internal */
+    private filterSub;
+    /**
+     * Reloads when `setFilter()` or `removeFilter()` changes the criteria.
+     * @remarks The criteria a block is read with is captured when the resource is built, so a
+     * filter added later reaches nothing until the rows are re-read. The `criteria` attribute
+     * already reloads through `criteriaChanged`; this gives the programmatic API the same
+     * behaviour instead of silently doing nothing.
+     * @internal
+     */
+    private subscribeToFilterChanges;
+    /** @internal */
+    private unsubscribeFromFilterChanges;
     deepClone(): Node;
     /**
      * Resets the grid data while keeping columnDefs and reloads data.
@@ -6462,10 +6672,58 @@ export declare class GridProInfiniteDatasource extends GridProInfiniteDatasource
     init(): Promise<void>;
     /** @internal */
     private clearReadyListener;
+    /**
+     * Whether the infinite row model can drive this resource.
+     * @remarks It pages a req/rep by sending CRITERIA_MATCH, ORDER_BY and OFFSET in DETAILS, which
+     * a request reply only accepts when it is declared `criteriaOnlyRequest`
+     * (`CRITERIA_ONLY_REQUEST` in its metadata). Without it the server expects its inputs in
+     * `REQUEST` instead and rejects every block, which on this row model surfaces as a grid that
+     * simply never fills. Report it once, up front, as the server-side model does.
+     * @returns `true` when the infinite model can be used, `false` after reporting a
+     * `resource-type` error.
+     * @internal
+     */
+    private isInfiniteSupportedForResource;
     /** @internal */
     private onDatasourceReady;
+    /**
+     * A pushed INSERT/DELETE changes which rows exist or their order, so the change is reported
+     * and then the rows are re-read (purge).
+     * @internal
+     */
+    private handleLiveRowsInvalidated;
+    /**
+     * A pushed MODIFY is already patched into the paging cache, so the change is reported and the
+     * grid only needs to re-render its blocks.
+     * @internal
+     */
+    private handleLiveRowsUpdated;
+    /**
+     * Turns a DATASERVER push into the same transaction the client-side datasource reports:
+     * partial MODIFY rows are merged into the held row, and a remove carries just the row id.
+     * @remarks Unlike the client-side model, a pushed row need not be held here - it may sit
+     * beyond the loaded blocks, in which case the grid will never show it.
+     *
+     * So a pushed INSERT is deliberately not reported: nothing here says where the new row sorts,
+     * and reporting an `add` for a row that lands at position 40,000 of an unscrolled grid would
+     * contradict the event's contract and leave the row held forever, since no block re-read ever
+     * delivers (or withdraws) it. Every INSERT is followed by a purge and re-read, which reports
+     * the row as `add` if and when it actually reaches the grid.
+     *
+     * A MODIFY for a row that is not held is skipped for the same reason; a DELETE is reported by
+     * the id it carries, and one that cannot be resolved to an id is skipped with a warning rather
+     * than matched against the wrong row.
+     * @internal
+     */
+    private reportLiveChange;
     destroy(): Promise<void>;
     restart(): Promise<void>;
+    /**
+     * Forgets every held row and tells consumers, as the client-side datasource does: the grid is
+     * dropping its rows (a reload, a filter or sort change, or teardown). `withColumnDefs` also
+     * clears the column definitions.
+     * @internal
+     */
     private clearRowData;
     /**
      * Honours `pollTriggerEvents` without polling: a commit ACK for one of the listed events
@@ -6902,7 +7160,7 @@ export declare enum GridProRendererTypes {
  * @fires base-datasource-connected - Fired when error state is cleared after connection succeeds
  * @fires datasource-loading-finished - Fired when pending stream transactions are flushed with no row changes
  * @fires datasource-no-data-available - Fired when loading finishes with an empty row set
- * @fires datasource-data-changed - Fired when row data changes from applied stream transactions. detail: `DataChangedEventDetail`
+ * @fires datasource-data-changed - Fired when rows are delivered to the grid, a live stream pushes a change, a poll detects one, or a re-read no longer returns a row; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`
  * @fires cache-filter-config - Fired to persist filter configuration for the grid
  * @fires refresh-server-side - Fired to request a server-side refresh. detail: `RefreshServerSideEventDetail`
  * @fires set-server-side-datasource - Fired to attach or clear the server-side row model datasource
@@ -6913,12 +7171,11 @@ export declare enum GridProRendererTypes {
  * @fires datasource-init - Fired when the server-side grid model should initialize data
  * @fires datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`
  * @fires datasource-filters-restored - Fired when persisted filters are reapplied
- * @fires datasource-data-cleared - Fired when server-side row data is cleared. detail: `DataClearedEventDetail`
+ * @fires datasource-data-cleared - Fired when the grid drops every row it held (reload, filter or sort change, destroy); `includeSchema` says whether the columns went too. detail: `DataClearedEventDetail`
  * @fires apply-server-side-transaction - Fired to apply a server-side row transaction
  * @fires datasource-ready - Fired when the host grid is ready to start loading data
  */
 export declare class GridProServerSideDatasource extends GridProServerSideDatasource_base {
-    serializer: JSONSerializer;
     pollingDatasource: Datasource;
     /**
      * Enable live updates for the grid.
@@ -6955,6 +7212,12 @@ export declare class GridProServerSideDatasource extends GridProServerSideDataso
     private onDatasourceReady;
     destroy(): Promise<void>;
     restart(): Promise<void>;
+    /**
+     * Forgets every held row and tells consumers, as the client-side datasource does: the grid is
+     * dropping its rows (a reload, a filter or sort change, or teardown). `withColumnDefs` also
+     * clears the column definitions.
+     * @internal
+     */
     private clearRowData;
     /**
      * Checks whether the resolved resource can be served through the Server-Side Row Model.
@@ -8877,6 +9140,16 @@ export declare type ServerSideDatasourceOptions = {
     onNoDataAvailableFunc?: () => void;
     /** Called when a server-side load finishes with one or more rows. */
     onDataAvailableFunc?: () => void;
+    /**
+     * Called with the rows just handed to AG Grid for a block. This is the only point at which
+     * rows leave the datasource, so it is where the host learns which rows the grid holds.
+     */
+    onRowsDeliveredFunc?: (rows: any[]) => void;
+    /**
+     * Called with the ids of rows a re-read of a block no longer returned - they left the grid
+     * (deleted on the server, or moved to a block that reports them again).
+     */
+    onRowsWithdrawnFunc?: (rowIds: string[]) => void;
     resourceName: string;
     resourceParams?: DataserverParams | RequestParams;
     resourceIndexes?: Map<string, string[]>;

package/dist/react.cjs

@@ -123,6 +123,11 @@ const StringEditor = React.forwardRef(function StringEditor(props, ref) {
   return React.createElement(customElements.getName(StringEditorWC) ?? '%%prefix%%-string-editor', { ...rest, ref }, children);
 });
 
+const GridProColumn = React.forwardRef(function GridProColumn(props, ref) {
+  const { children, ...rest } = props;
+  return React.createElement(customElements.getName(GridProColumnWC) ?? 'grid-pro-column', { ...rest, ref }, children);
+});
+
 const ActionRenderer = React.forwardRef(function ActionRenderer(props, ref) {
   const { children, ...rest } = props;
   return React.createElement(customElements.getName(ActionRendererWC) ?? '%%prefix%%-grid-pro-action-renderer', { ...rest, ref }, children);
@@ -163,16 +168,6 @@ const AgTextRenderer = React.forwardRef(function AgTextRenderer(props, ref) {
   return React.createElement(customElements.getName(AgTextRendererWC) ?? '%%prefix%%-grid-text-renderer', { ...rest, ref }, children);
 });
 
-const GridProColumn = React.forwardRef(function GridProColumn(props, ref) {
-  const { children, ...rest } = props;
-  return React.createElement(customElements.getName(GridProColumnWC) ?? 'grid-pro-column', { ...rest, ref }, children);
-});
-
-const ColumnSelection = React.forwardRef(function ColumnSelection(props, ref) {
-  const { children, ...rest } = props;
-  return React.createElement(customElements.getName(ColumnSelectionWC) ?? '%%prefix%%-column-selection', { ...rest, ref }, children);
-});
-
 const GridProClientSideDatasource = React.forwardRef(function GridProClientSideDatasource(props, ref) {
   const { onBaseDatasourceError, onDatasourceError, onBaseDatasourceConnected, onDatasourceLoadingFinished, onDatasourceNoDataAvailable, onDatasourceDataChanged, onDatasourceInitialize, onDatasourceDestroy, onDatasourceDataCleared, onDatasourceSchemaUpdated, onDatasourceFiltersRestored, onDatasourceDataLoaded, onDatasourceLoadingStarted, onDatasourceMoreDataAvailable, onDatasourceReady, onDatasourceInit, onMoreRowsChanged, onDatasourceSizeChanged, children, ...rest } = props;
   const _innerRef = React.useRef(null);
@@ -276,7 +271,7 @@ const GridProClientSideDatasource = React.forwardRef(function GridProClientSideD
 });
 
 const GridProInfiniteDatasource = React.forwardRef(function GridProInfiniteDatasource(props, ref) {
-  const { onBaseDatasourceError, onDatasourceError, onBaseDatasourceConnected, onDatasourceInitialize, onDatasourceInit, onDatasourceSchemaUpdated, onSetInfiniteDatasource, onRefreshInfiniteCache, onAddGridCssClass, onRemoveGridCssClass, onCacheFilterConfig, onDatasourceDataCleared, onDatasourceFiltersRestored, onDatasourceLoadingFinished, onDatasourceNoDataAvailable, onDatasourceDataChanged, children, ...rest } = props;
+  const { onBaseDatasourceError, onDatasourceError, onBaseDatasourceConnected, onDatasourceInitialize, onDatasourceInit, onDatasourceSchemaUpdated, onDatasourceDataChanged, onSetInfiniteDatasource, onRefreshInfiniteCache, onAddGridCssClass, onRemoveGridCssClass, onCacheFilterConfig, onDatasourceDataCleared, onDatasourceLoadingFinished, onDatasourceNoDataAvailable, onDatasourceFiltersRestored, children, ...rest } = props;
   const _innerRef = React.useRef(null);
   const _onBaseDatasourceErrorRef = React.useRef(onBaseDatasourceError);
   _onBaseDatasourceErrorRef.current = onBaseDatasourceError;
@@ -290,6 +285,8 @@ const GridProInfiniteDatasource = React.forwardRef(function GridProInfiniteDatas
   _onDatasourceInitRef.current = onDatasourceInit;
   const _onDatasourceSchemaUpdatedRef = React.useRef(onDatasourceSchemaUpdated);
   _onDatasourceSchemaUpdatedRef.current = onDatasourceSchemaUpdated;
+  const _onDatasourceDataChangedRef = React.useRef(onDatasourceDataChanged);
+  _onDatasourceDataChangedRef.current = onDatasourceDataChanged;
   const _onSetInfiniteDatasourceRef = React.useRef(onSetInfiniteDatasource);
   _onSetInfiniteDatasourceRef.current = onSetInfiniteDatasource;
   const _onRefreshInfiniteCacheRef = React.useRef(onRefreshInfiniteCache);
@@ -302,14 +299,12 @@ const GridProInfiniteDatasource = React.forwardRef(function GridProInfiniteDatas
   _onCacheFilterConfigRef.current = onCacheFilterConfig;
   const _onDatasourceDataClearedRef = React.useRef(onDatasourceDataCleared);
   _onDatasourceDataClearedRef.current = onDatasourceDataCleared;
-  const _onDatasourceFiltersRestoredRef = React.useRef(onDatasourceFiltersRestored);
-  _onDatasourceFiltersRestoredRef.current = onDatasourceFiltersRestored;
   const _onDatasourceLoadingFinishedRef = React.useRef(onDatasourceLoadingFinished);
   _onDatasourceLoadingFinishedRef.current = onDatasourceLoadingFinished;
   const _onDatasourceNoDataAvailableRef = React.useRef(onDatasourceNoDataAvailable);
   _onDatasourceNoDataAvailableRef.current = onDatasourceNoDataAvailable;
-  const _onDatasourceDataChangedRef = React.useRef(onDatasourceDataChanged);
-  _onDatasourceDataChangedRef.current = onDatasourceDataChanged;
+  const _onDatasourceFiltersRestoredRef = React.useRef(onDatasourceFiltersRestored);
+  _onDatasourceFiltersRestoredRef.current = onDatasourceFiltersRestored;
   React.useLayoutEffect(() => {
     const el = _innerRef.current;
     if (!el) return;
@@ -325,6 +320,8 @@ const GridProInfiniteDatasource = React.forwardRef(function GridProInfiniteDatas
     el.addEventListener('datasource-init', _onDatasourceInitFn);
     const _onDatasourceSchemaUpdatedFn = (e) => _onDatasourceSchemaUpdatedRef.current?.(e);
     el.addEventListener('datasource-schema-updated', _onDatasourceSchemaUpdatedFn);
+    const _onDatasourceDataChangedFn = (e) => _onDatasourceDataChangedRef.current?.(e);
+    el.addEventListener('datasource-data-changed', _onDatasourceDataChangedFn);
     const _onSetInfiniteDatasourceFn = (e) => _onSetInfiniteDatasourceRef.current?.(e);
     el.addEventListener('set-infinite-datasource', _onSetInfiniteDatasourceFn);
     const _onRefreshInfiniteCacheFn = (e) => _onRefreshInfiniteCacheRef.current?.(e);
@@ -337,14 +334,12 @@ const GridProInfiniteDatasource = React.forwardRef(function GridProInfiniteDatas
     el.addEventListener('cache-filter-config', _onCacheFilterConfigFn);
     const _onDatasourceDataClearedFn = (e) => _onDatasourceDataClearedRef.current?.(e);
     el.addEventListener('datasource-data-cleared', _onDatasourceDataClearedFn);
-    const _onDatasourceFiltersRestoredFn = (e) => _onDatasourceFiltersRestoredRef.current?.(e);
-    el.addEventListener('datasource-filters-restored', _onDatasourceFiltersRestoredFn);
     const _onDatasourceLoadingFinishedFn = (e) => _onDatasourceLoadingFinishedRef.current?.(e);
     el.addEventListener('datasource-loading-finished', _onDatasourceLoadingFinishedFn);
     const _onDatasourceNoDataAvailableFn = (e) => _onDatasourceNoDataAvailableRef.current?.(e);
     el.addEventListener('datasource-no-data-available', _onDatasourceNoDataAvailableFn);
-    const _onDatasourceDataChangedFn = (e) => _onDatasourceDataChangedRef.current?.(e);
-    el.addEventListener('datasource-data-changed', _onDatasourceDataChangedFn);
+    const _onDatasourceFiltersRestoredFn = (e) => _onDatasourceFiltersRestoredRef.current?.(e);
+    el.addEventListener('datasource-filters-restored', _onDatasourceFiltersRestoredFn);
     return () => {
       el.removeEventListener('base-datasource-error', _onBaseDatasourceErrorFn);
       el.removeEventListener('datasource-error', _onDatasourceErrorFn);
@@ -352,16 +347,16 @@ const GridProInfiniteDatasource = React.forwardRef(function GridProInfiniteDatas
       el.removeEventListener('datasource-initialize', _onDatasourceInitializeFn);
       el.removeEventListener('datasource-init', _onDatasourceInitFn);
       el.removeEventListener('datasource-schema-updated', _onDatasourceSchemaUpdatedFn);
+      el.removeEventListener('datasource-data-changed', _onDatasourceDataChangedFn);
       el.removeEventListener('set-infinite-datasource', _onSetInfiniteDatasourceFn);
       el.removeEventListener('refresh-infinite-cache', _onRefreshInfiniteCacheFn);
       el.removeEventListener('add-grid-css-class', _onAddGridCssClassFn);
       el.removeEventListener('remove-grid-css-class', _onRemoveGridCssClassFn);
       el.removeEventListener('cache-filter-config', _onCacheFilterConfigFn);
       el.removeEventListener('datasource-data-cleared', _onDatasourceDataClearedFn);
-      el.removeEventListener('datasource-filters-restored', _onDatasourceFiltersRestoredFn);
       el.removeEventListener('datasource-loading-finished', _onDatasourceLoadingFinishedFn);
       el.removeEventListener('datasource-no-data-available', _onDatasourceNoDataAvailableFn);
-      el.removeEventListener('datasource-data-changed', _onDatasourceDataChangedFn);
+      el.removeEventListener('datasource-filters-restored', _onDatasourceFiltersRestoredFn);
     };
   }, []);
   return React.createElement(customElements.getName(GridProInfiniteDatasourceWC) ?? 'grid-pro-infinite-datasource', { ...rest, ref: _mergeRefs(_innerRef, ref) }, children);
@@ -474,6 +469,11 @@ const GridProServerSideDatasource = React.forwardRef(function GridProServerSideD
   return React.createElement(customElements.getName(GridProServerSideDatasourceWC) ?? 'grid-pro-server-side-datasource', { ...rest, ref: _mergeRefs(_innerRef, ref) }, children);
 });
 
+const ColumnSelection = React.forwardRef(function ColumnSelection(props, ref) {
+  const { children, ...rest } = props;
+  return React.createElement(customElements.getName(ColumnSelectionWC) ?? '%%prefix%%-column-selection', { ...rest, ref }, children);
+});
+
 const GridProGenesisDatasource = React.forwardRef(function GridProGenesisDatasource(props, ref) {
   const { onBaseDatasourceError, onDatasourceError, onBaseDatasourceConnected, onDatasourceLoadingFinished, onDatasourceNoDataAvailable, onDatasourceDataChanged, onDatasourceInitialize, onDatasourceDestroy, onDatasourceDataCleared, onDatasourceSchemaUpdated, onDatasourceFiltersRestored, onDatasourceDataLoaded, onDatasourceLoadingStarted, onDatasourceMoreDataAvailable, onDatasourceReady, onDatasourceInit, onMoreRowsChanged, onDatasourceSizeChanged, children, ...rest } = props;
   const _innerRef = React.useRef(null);
@@ -590,6 +590,7 @@ module.exports = {
   NumberEditor,
   SelectEditor,
   StringEditor,
+  GridProColumn,
   ActionRenderer,
   ActionsMenuRenderer,
   BooleanRenderer,
@@ -598,11 +599,10 @@ module.exports = {
   StatusPillRenderer,
   AgTextFieldRenderer,
   AgTextRenderer,
-  GridProColumn,
-  ColumnSelection,
   GridProClientSideDatasource,
   GridProInfiniteDatasource,
   GridProServerSideDatasource,
+  ColumnSelection,
   GridProGenesisDatasource,
   MulticolumnDropdown,
 };