@genesislcap/grid-pro 15.16.0 → 15.17.0

package/dist/grid-pro.d.ts

@@ -679,6 +679,67 @@ export declare const convertToKebabCase: (value: string) => string;
  */
 export declare function copyAttributesToGridOptions(gridOptions: any, component: Record<string, any>): any;
 
+/**
+ * Builds the class rules that flash rows matching `criteria`, together with the context menu
+ * that lets a user recolor, retime, or narrow that flash to a single cell.
+ *
+ * The rules are created once and never replaced, because a grid backed by a Genesis datasource
+ * keeps the options it was created with — handing it new rules later would change nothing. Each
+ * rule instead asks, as it runs, whether its scope is the one currently selected, so switching
+ * target only needs the rows redrawn.
+ *
+ * ```ts
+ * const alert = createRowAlert(criteria, { persistPreferencesKey: 'orders.row-alert' });
+ * gridOptions = {
+ *   rowClassRules: alert.rowClassRules,
+ *   defaultColDef: alert.defaultColDef,
+ *   getContextMenuItems: alert.getContextMenuItems,
+ * };
+ * ```
+ *
+ * Alerts sharing a `persistPreferencesKey` share their preferences, so a page of grids that each
+ * watch for something different still answers to one setting.
+ *
+ * Pairs with {@link DatasourceRowMatchTracker}: give both the same criteria and a tab can say
+ * there is work to do while the grid shows which rows it meant.
+ *
+ * @public
+ */
+export declare function createRowAlert(criteria: RowMatchCriteria, options?: RowAlertOptions): RowAlert;
+
+/**
+ * Cell class rules that flag only the `flashField` cell of a matching row, for spreading into
+ * `gridOptions.defaultColDef.cellClassRules`.
+ *
+ * They belong on `defaultColDef` rather than a single column because AG Grid has no grid-level
+ * `cellClassRules`, and the rule itself checks which column it is running against.
+ *
+ * @public
+ */
+export declare function createRowMatchCellClassRules(criteria: RowMatchCriteria): Record<string, (params: {
+    data?: unknown;
+    colDef: {
+        field?: string;
+    };
+}) => boolean>;
+
+/**
+ * Row class rules that flag rows meeting {@link RowMatchCriteria}, for spreading into
+ * `gridOptions.rowClassRules`.
+ *
+ * Pairs with {@link DatasourceRowMatchTracker}: the tracker decides whether a tab should flash,
+ * these decide which rows made it flash. Both take the same criteria, so the two cannot disagree.
+ *
+ * ```ts
+ * gridOptions = { rowClassRules: createRowMatchClassRules(criteria) };
+ * ```
+ *
+ * @public
+ */
+export declare function createRowMatchClassRules(criteria: RowMatchCriteria): Record<string, (params: {
+    data?: unknown;
+}) => boolean>;
+
 /**
  * The delimiter for the criteria string.
  * @public
@@ -771,6 +832,65 @@ export declare const datasourceEventNames: {
     readonly applyServerSideTransaction: "apply-server-side-transaction";
 };
 
+/**
+ * Tracks which datasource rows satisfy {@link RowMatchCriteria} as stream updates arrive,
+ * and reports whether any currently do.
+ *
+ * Rows are tracked incrementally from `add` / `update` / `remove` deltas rather than by
+ * rescanning the grid, so cost is proportional to the update rather than to the row count.
+ *
+ * The typical consumer flags a tab while a background grid still holds rows needing
+ * attention:
+ *
+ * ```ts
+ * const tracker = new DatasourceRowMatchTracker(
+ *   { rowIdField: 'ORDER_ID', stateField: 'ORDER_STATE', stateValue: 'PENDING' },
+ *   (active) => { tab.alert = active; },
+ * );
+ * const stop = tracker.observe(datasourceElement);
+ * ```
+ *
+ * Frameworks that surface the datasource events as props can feed the tracker directly with
+ * {@link DatasourceRowMatchTracker.handleDataChanged} and
+ * {@link DatasourceRowMatchTracker.handleDataCleared} instead of calling `observe`.
+ *
+ * Passing the same criteria to `createRowMatchClassRules` flashes the matching rows themselves, so
+ * a tab that says there is work to do leads to a grid that shows which rows it meant.
+ *
+ * Criteria are fixed for the tracker's life. To watch for something else, build a new tracker and
+ * reload the datasource, so rows already delivered are replayed against the new rules.
+ *
+ * @public
+ */
+export declare class DatasourceRowMatchTracker {
+    private readonly criteria;
+    private readonly onActiveChanged;
+    private readonly matchedRowIds;
+    private lastReportedActive;
+    constructor(criteria: RowMatchCriteria, onActiveChanged: RowMatchActiveChanged);
+    /** True while at least one tracked row matches. */
+    get active(): boolean;
+    /** How many tracked rows currently match. */
+    get matchCount(): number;
+    /**
+     * Forgets every tracked row. Call when the grid's filter or search criteria change, so a
+     * stale alert does not survive into a result set that no longer contains those rows.
+     */
+    reset(): void;
+    /** Applies a `datasource-data-changed` detail. */
+    handleDataChanged(detail: DataChangedEventDetail | undefined): void;
+    /** Applies a `datasource-data-cleared` event. */
+    handleDataCleared(): void;
+    /**
+     * Subscribes to the datasource events on `target`.
+     *
+     * @returns a function that removes the listeners.
+     */
+    observe(target: EventTarget): () => void;
+    private syncRow;
+    private report;
+}
+
 /**
  * Available datasource types
  * @remarks - This type is used to define what kind of datasource will be used in components like entity manager.
@@ -858,6 +978,36 @@ export declare const defaultGridProConfig: {
     shadowOptions: any;
 };
 
+/**
+ * Colors offered by default. Each resolves a design token so the menu follows the host
+ * application's theme, falling back to a fixed color for design systems that lack the token.
+ *
+ * @public
+ */
+export declare const defaultRowAlertColorPresets: readonly RowAlertPreset<string>[];
+
+/**
+ * Where preferences start before a user changes anything.
+ *
+ * @public
+ */
+export declare const defaultRowAlertPreferences: RowAlertPreferences;
+
+/**
+ * Flash rates offered by default.
+ *
+ * @public
+ */
+export declare const defaultRowAlertRatePresets: readonly RowAlertPreset<number>[];
+
+/**
+ * Flash targets offered by default. Cell scope only has an effect when the criteria name a
+ * `flashField`.
+ *
+ * @public
+ */
+export declare const defaultRowAlertScopePresets: readonly RowAlertPreset<RowAlertScope>[];
+
 /** Class name used to hide elements with display:none */
 export declare const DISPLAY_NONE_CLASS = "dnone";
 
@@ -5827,6 +5977,8 @@ export declare class KVStorageStatePersistence implements StatePersistence {
     saveFilterModel(persistFilterModelKey: string, filterModel: {
         [key: string]: any;
     }): Promise<void>;
+    getRowAlertPreferences(persistRowAlertKey: string): Promise<Partial<RowAlertPreferences>>;
+    saveRowAlertPreferences(persistRowAlertKey: string, preferences: RowAlertPreferences): Promise<void>;
 }
 
 /**
@@ -5911,6 +6063,8 @@ export declare class LocalStorageStatePersistence implements StatePersistence {
     saveFilterModel(persistFilterModelKey: string, filterModel: {
         [key: string]: any;
     }): Promise<void>;
+    getRowAlertPreferences(persistRowAlertKey: string): Promise<Partial<RowAlertPreferences>>;
+    saveRowAlertPreferences(persistRowAlertKey: string, preferences: RowAlertPreferences): Promise<void>;
 }
 
 /**
@@ -5919,6 +6073,13 @@ export declare class LocalStorageStatePersistence implements StatePersistence {
  */
 export declare const logger: Logger;
 
+/**
+ * True when the row satisfies any resolved AND-group.
+ *
+ * @public
+ */
+export declare function matchesRowCriteria(criteria: RowMatchCriteria, row: Record<string, unknown> | null | undefined): boolean;
+
 /**
  * Merges two arrays, one of `ColDef` and one of `ColumnState`, and deduplicates them.
  * @remarks ColDef uses `field` and ColumnState uses `colId` to identify columns.
@@ -6454,6 +6615,14 @@ export declare interface MultiselectEditorParams extends ICellEditorParams {
     datasourceOptions: DatasourceOptions[];
 }
 
+/**
+ * Discards anything unusable from stored preferences, so a hand-edited or outdated entry falls
+ * back to the default rather than leaving alerts invisible.
+ *
+ * @internal
+ */
+export declare function normalizeRowAlertPreferences(value: Partial<RowAlertPreferences> | null | undefined): RowAlertPreferences;
+
 /**
  * The AG Number Editor element.
  * @public
@@ -6563,6 +6732,159 @@ export declare type ReloadStatusBarParams = {
  */
 export declare function resolveVisibleColumnFields(displayedColumns: DisplayedColumnLike[] | null | undefined, colDefs: readonly unknown[] | null | undefined): string[];
 
+/**
+ * Class the grid puts on just the `flashField` cell of a matching row, for grids that flash a
+ * single column rather than the whole row.
+ *
+ * @public
+ */
+export declare const ROW_MATCH_ALERT_CELL_CLASS = "grid-pro-row-alert-cell";
+
+/**
+ * Class the grid puts on rows satisfying the criteria. The grid's own styles flash it in step
+ * with any alerting tab, so a tab that draws you to a grid also shows you which rows caused it.
+ *
+ * @public
+ */
+export declare const ROW_MATCH_ALERT_CLASS = "grid-pro-row-alert";
+
+/**
+ * Everything a grid needs to flash the rows meeting some criteria, and to let the user retune
+ * that flash.
+ *
+ * @public
+ */
+export declare interface RowAlert {
+    /** Assign to `gridOptions.rowClassRules`. */
+    readonly rowClassRules: Record<string, (params: {
+        data?: unknown;
+    }) => boolean>;
+    /**
+     * Assign to `gridOptions.defaultColDef`, which is where cell class rules have to live — AG Grid
+     * has no grid-level equivalent. Needed even under row scope, since the user can switch.
+     */
+    readonly defaultColDef: {
+        cellClassRules: Record<string, (params: {
+            data?: unknown;
+            colDef: {
+                field?: string;
+            };
+        }) => boolean>;
+    };
+    /** The preferences in force right now. */
+    readonly preferences: RowAlertPreferences;
+    /**
+     * Drop-in for `gridOptions.getContextMenuItems`: the grid's own items, then the presets.
+     * Applications that already build a menu can call {@link RowAlert.createMenuItem} instead.
+     */
+    getContextMenuItems(params: RowAlertMenuParams): any[];
+    /** The presets submenu on its own, for composing into an existing context menu. */
+    createMenuItem(api?: RowAlertGridApi): RowAlertMenuItem;
+    /** Applies and persists a change. */
+    setPreferences(patch: Partial<RowAlertPreferences>): void;
+    /** Returns every preference to its default. */
+    reset(): void;
+    /** Called after any change, for frameworks that need to re-render. Returns an unsubscribe. */
+    subscribe(listener: (preferences: RowAlertPreferences) => void): () => void;
+}
+
+/**
+ * The part of AG Grid's api this needs, to bring rows already on screen in line with a change.
+ *
+ * @public
+ */
+export declare interface RowAlertGridApi {
+    redrawRows?: () => void;
+}
+
+/**
+ * An entry in the presets menu, in the shape AG Grid's `MenuItemDef` expects.
+ *
+ * @public
+ */
+export declare interface RowAlertMenuItem {
+    name: string;
+    checked?: boolean;
+    action?: () => void;
+    subMenu?: RowAlertMenuItem[];
+}
+
+/**
+ * The parts of AG Grid's context menu params this needs. Described structurally, like the class
+ * rules, because grid-pro serves two AG Grid generations whose own types are not interchangeable.
+ *
+ * @public
+ */
+export declare interface RowAlertMenuParams {
+    defaultItems?: any[];
+    api?: RowAlertGridApi;
+}
+
+/**
+ * Options for {@link createRowAlert}.
+ *
+ * @public
+ */
+export declare interface RowAlertOptions {
+    /**
+     * Remembers the user's choices under this key, through the injected
+     * {@link (StatePersistence:interface)} — the same mechanism as column state, so an application
+     * that has
+     * moved persistence server-side gets these preferences per user too. Omit to keep changes for
+     * the lifetime of the page.
+     */
+    persistPreferencesKey?: string;
+    /** Element the CSS variables are set on. Defaults to the document, which every grid inherits. */
+    target?: HTMLElement;
+    /**
+     * Further CSS custom properties to hold the chosen color, for surfaces outside the grid that
+     * should flash in the same shade — `--tab-alert-color`, say, in an application whose tab
+     * headers alert alongside their rows.
+     */
+    mirrorColorTo?: readonly string[];
+    /** Overrides the colors offered in the menu. */
+    colorPresets?: readonly RowAlertPreset<string>[];
+    /** Overrides the flash rates offered in the menu. */
+    ratePresets?: readonly RowAlertPreset<number>[];
+    /** Heading the presets sit under in the context menu. Defaults to `Alert flash`. */
+    menuLabel?: string;
+    /** Starting preferences, before anything stored is loaded. */
+    preferences?: Partial<RowAlertPreferences>;
+    /** Supplied only by tests; otherwise resolved from the container. */
+    statePersistence?: StatePersistence;
+}
+
+/**
+ * The parts of a row alert a user can change from the grid's context menu.
+ *
+ * @public
+ */
+export declare interface RowAlertPreferences {
+    /** Any CSS color, including a `var()` reference to a design token. */
+    color: string;
+    /** How long one flash cycle takes. Shared by every alerting surface on the page. */
+    durationMs: number;
+    scope: RowAlertScope;
+}
+
+/**
+ * A labelled choice offered in the context menu.
+ *
+ * @public
+ */
+export declare interface RowAlertPreset<TValue> {
+    id: string;
+    label: string;
+    value: TValue;
+}
+
+/**
+ * Whether an alerting row flashes in full, or only the column its criteria name.
+ *
+ * @public
+ */
+export declare type RowAlertScope = 'row' | 'cell';
+
 /**
  * Row Count Status Bar Component for Server-Side Infinite Scroll
  * Displays current row count information for server-side grids.
@@ -6579,6 +6901,110 @@ export declare class RowCountStatusBarComponent implements IStatusPanelComp {
     destroy(): void;
 }
 
+/**
+ * Match of a single field to an expected value.
+ *
+ * @public
+ */
+export declare interface RowFieldMatch {
+    field: string;
+    /**
+     * Value to compare against. Use `null` with `==` / `!=` to mean empty
+     * (`null`, `undefined` or `''`) or not-empty respectively.
+     */
+    value: string | number | boolean | null;
+    /** Comparison to apply. Defaults to `==`. */
+    op?: RowFieldMatchOp;
+}
+
+/**
+ * Comparison used when matching a field. Defaults to `==`.
+ *
+ * Relational operators (`>`, `>=`, `<`, `<=`) compare numerically — both sides are coerced with
+ * `Number(...)`, and the condition fails if either is not a finite number.
+ *
+ * @public
+ */
+export declare type RowFieldMatchOp = '==' | '!=' | '>' | '>=' | '<' | '<=';
+
+/**
+ * Notified whenever the tracker flips between "some rows match" and "none match".
+ *
+ * @public
+ */
+export declare type RowMatchActiveChanged = (active: boolean) => void;
+
+/**
+ * Flash for rows carrying the classes that `createRowMatchClassRules` and
+ * `createRowMatchCellClassRules` apply.
+ *
+ * These live in the grid's own stylesheet because AG Grid renders inside this shadow root, out of
+ * reach of an app's CSS. The phase comes from the document-level clock, which inherits through the
+ * shadow boundary, so a flashing row keeps step with the flashing tab that sent you looking for it.
+ *
+ * Any grid composition that does not include {@link foundationGridProStyles} needs to include this
+ * as well, otherwise its rows silently never flash.
+ *
+ * @public
+ */
+export declare const rowMatchAlertStyles: ElementStyles;
+
+/**
+ * Declarative rules for deciding whether a datasource row is "of interest" — most commonly
+ * whether it still needs attention, so a tab can be flagged while such rows exist.
+ *
+ * Simple form: `stateField` / `stateValue`, optionally narrowed with `and` (all AND'd).
+ * Flexible form: `anyOf`, an OR of AND-groups, which takes precedence when set.
+ *
+ * @public
+ */
+export declare interface RowMatchCriteria {
+    /** Field holding a stable row identity, used to track rows across stream updates. */
+    rowIdField: string;
+    /**
+     * Primary field match. Required unless `anyOf` is set.
+     * Use `null` to match empty values (`null`, `undefined` or `''`).
+     */
+    stateField?: string;
+    stateValue?: string | number | boolean | null;
+    /** Comparison for `stateField` / `stateValue`. Defaults to `==`. */
+    stateOp?: RowFieldMatchOp;
+    /** Additional AND conditions on top of `stateField` / `stateValue`. Ignored when `anyOf` is set. */
+    and?: RowFieldMatch[];
+    /**
+     * OR of AND-groups. A row matches when every entry of any one group matches.
+     * When set, this is used instead of `stateField` / `stateValue` / `and`
+     * (those shorthand fields are ignored).
+     *
+     * @example
+     * ```ts
+     * // (PENDING and unassigned) OR (LIVE)
+     * anyOf: [
+     *   [
+     *     { field: 'ORDER_STATE', value: 'PENDING' },
+     *     { field: 'ASSIGNED_TO', value: null },
+     *   ],
+     *   [{ field: 'ORDER_STATE', value: 'LIVE' }],
+     * ]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Quantity above 100, or a flagged exception
+     * anyOf: [
+     *   [{ field: 'QUANTITY', op: '>', value: 100 }],
+     *   [{ field: 'IS_EXCEPTION', value: true }],
+     * ]
+     * ```
+     */
+    anyOf?: RowFieldMatch[][];
+    /**
+     * Column to flash instead of the whole row, for grids where a full-width flash is too much.
+     * Only consulted by the cell class rules; leave unset to flash the entire row.
+     */
+    flashField?: string;
+}
+
 /**
  * Sanitizes persisted column state by removing unsupported keys.
  * @remarks Some AG Grid versions include legacy properties (e.g. `sortType`) that should not
@@ -6756,6 +7182,21 @@ export declare interface StatePersistence {
     saveFilterModel(persistFilterModelKey: string, filterModel: {
         [key: string]: any;
     }): Promise<void>;
+    /**
+     * Returns the row alert preferences for the given key, or `undefined` when none are stored.
+     *
+     * Optional so implementations written before row alerts existed continue to satisfy this
+     * interface; row alerts fall back to their defaults when it is absent.
+     * @public
+     */
+    getRowAlertPreferences?(persistRowAlertKey: string): Promise<Partial<RowAlertPreferences>>;
+    /**
+     * Saves the row alert preferences for the given key.
+     *
+     * Optional — see {@link (StatePersistence:interface).getRowAlertPreferences}.
+     * @public
+     */
+    saveRowAlertPreferences?(persistRowAlertKey: string, preferences: RowAlertPreferences): Promise<void>;
 }
 
 /**

package/dist/react.cjs

@@ -91,11 +91,6 @@ const GridPro = React.forwardRef(function GridPro(props, ref) {
   return React.createElement(customElements.getName(GridProWC) ?? '%%prefix%%-grid-pro', { ...rest, ref: _mergeRefs(_innerRef, ref) }, children);
 });
 
-const GridProCell = React.forwardRef(function GridProCell(props, ref) {
-  const { children, ...rest } = props;
-  return React.createElement(customElements.getName(GridProCellWC) ?? 'grid-pro-cell', { ...rest, ref }, children);
-});
-
 const DateEditor = React.forwardRef(function DateEditor(props, ref) {
   const { children, ...rest } = props;
   return React.createElement(customElements.getName(DateEditorWC) ?? '%%prefix%%-date-editor', { ...rest, ref }, children);
@@ -121,9 +116,9 @@ 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 GridProCell = React.forwardRef(function GridProCell(props, ref) {
   const { children, ...rest } = props;
-  return React.createElement(customElements.getName(GridProColumnWC) ?? 'grid-pro-column', { ...rest, ref }, children);
+  return React.createElement(customElements.getName(GridProCellWC) ?? 'grid-pro-cell', { ...rest, ref }, children);
 });
 
 const ActionRenderer = React.forwardRef(function ActionRenderer(props, ref) {
@@ -166,6 +161,11 @@ 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 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);
@@ -485,13 +485,12 @@ const MulticolumnDropdown = React.forwardRef(function MulticolumnDropdown(props,
 module.exports = {
   GridProBeta,
   GridPro,
-  GridProCell,
   DateEditor,
   MultiselectEditor,
   NumberEditor,
   SelectEditor,
   StringEditor,
-  GridProColumn,
+  GridProCell,
   ActionRenderer,
   ActionsMenuRenderer,
   BooleanRenderer,
@@ -500,6 +499,7 @@ module.exports = {
   StatusPillRenderer,
   AgTextFieldRenderer,
   AgTextRenderer,
+  GridProColumn,
   GridProClientSideDatasource,
   GridProServerSideDatasource,
   GridProGenesisDatasource,

package/dist/react.mjs

@@ -89,11 +89,6 @@ export const GridPro = React.forwardRef(function GridPro(props, ref) {
   return React.createElement(customElements.getName(GridProWC) ?? '%%prefix%%-grid-pro', { ...rest, ref: _mergeRefs(_innerRef, ref) }, children);
 });
 
-export const GridProCell = React.forwardRef(function GridProCell(props, ref) {
-  const { children, ...rest } = props;
-  return React.createElement(customElements.getName(GridProCellWC) ?? 'grid-pro-cell', { ...rest, ref }, children);
-});
-
 export const DateEditor = React.forwardRef(function DateEditor(props, ref) {
   const { children, ...rest } = props;
   return React.createElement(customElements.getName(DateEditorWC) ?? '%%prefix%%-date-editor', { ...rest, ref }, children);
@@ -119,9 +114,9 @@ export const StringEditor = React.forwardRef(function StringEditor(props, ref) {
   return React.createElement(customElements.getName(StringEditorWC) ?? '%%prefix%%-string-editor', { ...rest, ref }, children);
 });
 
-export const GridProColumn = React.forwardRef(function GridProColumn(props, ref) {
+export const GridProCell = React.forwardRef(function GridProCell(props, ref) {
   const { children, ...rest } = props;
-  return React.createElement(customElements.getName(GridProColumnWC) ?? 'grid-pro-column', { ...rest, ref }, children);
+  return React.createElement(customElements.getName(GridProCellWC) ?? 'grid-pro-cell', { ...rest, ref }, children);
 });
 
 export const ActionRenderer = React.forwardRef(function ActionRenderer(props, ref) {
@@ -164,6 +159,11 @@ export const AgTextRenderer = React.forwardRef(function AgTextRenderer(props, re
   return React.createElement(customElements.getName(AgTextRendererWC) ?? '%%prefix%%-grid-text-renderer', { ...rest, ref }, children);
 });
 
+export const GridProColumn = React.forwardRef(function GridProColumn(props, ref) {
+  const { children, ...rest } = props;
+  return React.createElement(customElements.getName(GridProColumnWC) ?? 'grid-pro-column', { ...rest, ref }, children);
+});
+
 export 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);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/grid-pro",
   "description": "Genesis Foundation AG Grid",
-  "version": "15.16.0",
+  "version": "15.17.0",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -40,20 +40,20 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "15.16.0",
-    "@genesislcap/genx": "15.16.0",
-    "@genesislcap/rollup-builder": "15.16.0",
-    "@genesislcap/ts-builder": "15.16.0",
-    "@genesislcap/uvu-playwright-builder": "15.16.0",
-    "@genesislcap/vite-builder": "15.16.0",
-    "@genesislcap/webpack-builder": "15.16.0"
+    "@genesislcap/foundation-testing": "15.17.0",
+    "@genesislcap/genx": "15.17.0",
+    "@genesislcap/rollup-builder": "15.17.0",
+    "@genesislcap/ts-builder": "15.17.0",
+    "@genesislcap/uvu-playwright-builder": "15.17.0",
+    "@genesislcap/vite-builder": "15.17.0",
+    "@genesislcap/webpack-builder": "15.17.0"
   },
   "dependencies": {
-    "@genesislcap/foundation-comms": "15.16.0",
-    "@genesislcap/foundation-criteria": "15.16.0",
-    "@genesislcap/foundation-logger": "15.16.0",
-    "@genesislcap/foundation-ui": "15.16.0",
-    "@genesislcap/foundation-utils": "15.16.0",
+    "@genesislcap/foundation-comms": "15.17.0",
+    "@genesislcap/foundation-criteria": "15.17.0",
+    "@genesislcap/foundation-logger": "15.17.0",
+    "@genesislcap/foundation-ui": "15.17.0",
+    "@genesislcap/foundation-utils": "15.17.0",
     "@microsoft/fast-colors": "5.3.1",
     "@microsoft/fast-components": "2.30.6",
     "@microsoft/fast-element": "1.14.0",
@@ -91,5 +91,5 @@
       "require": "./dist/react.cjs"
     }
   },
-  "gitHead": "2cacfdef54a332ee571ae784b5b7629cf66f050f"
+  "gitHead": "2e040c4861f6acfde7afef48b60555548fac8708"
 }