@genesislcap/grid-pro 15.16.0 → 15.17.0

package/dist/esm/datasource/row-match.classes.js

@@ -0,0 +1,53 @@
+import { installAlertFlashClock } from '@genesislcap/foundation-ui';
+import { matchesRowCriteria } from './row-match.types';
+/**
+ * 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 const ROW_MATCH_ALERT_CLASS = 'grid-pro-row-alert';
+/**
+ * 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 const ROW_MATCH_ALERT_CELL_CLASS = 'grid-pro-row-alert-cell';
+/**
+ * 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 function createRowMatchClassRules(criteria) {
+    installAlertFlashClock();
+    return {
+        [ROW_MATCH_ALERT_CLASS]: (params) => matchesRowCriteria(criteria, params.data),
+    };
+}
+/**
+ * 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 function createRowMatchCellClassRules(criteria) {
+    installAlertFlashClock();
+    const { flashField } = criteria;
+    return {
+        [ROW_MATCH_ALERT_CELL_CLASS]: (params) => !!flashField &&
+            params.colDef.field === flashField &&
+            matchesRowCriteria(criteria, params.data),
+    };
+}

package/dist/esm/datasource/row-match.tracker.js

@@ -0,0 +1,117 @@
+import { datasourceEventNames, } from '../grid-pro-genesis-datasource/datasource-events.types';
+import { matchesRowCriteria } from './row-match.types';
+/**
+ * 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 class DatasourceRowMatchTracker {
+    constructor(criteria, onActiveChanged) {
+        this.criteria = criteria;
+        this.onActiveChanged = onActiveChanged;
+        this.matchedRowIds = new Set();
+        this.lastReportedActive = false;
+    }
+    /** True while at least one tracked row matches. */
+    get active() {
+        return this.matchedRowIds.size > 0;
+    }
+    /** How many tracked rows currently match. */
+    get matchCount() {
+        return this.matchedRowIds.size;
+    }
+    /**
+     * 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() {
+        this.matchedRowIds.clear();
+        this.report();
+    }
+    /** Applies a `datasource-data-changed` detail. */
+    handleDataChanged(detail) {
+        var _a;
+        const { add = [], update = [], remove = [] } = (_a = detail === null || detail === void 0 ? void 0 : detail.changes) !== null && _a !== void 0 ? _a : {};
+        for (const row of remove) {
+            this.syncRow(row, true);
+        }
+        for (const row of add) {
+            this.syncRow(row, false);
+        }
+        for (const row of update) {
+            this.syncRow(row, false);
+        }
+        this.report();
+    }
+    /** Applies a `datasource-data-cleared` event. */
+    handleDataCleared() {
+        this.reset();
+    }
+    /**
+     * Subscribes to the datasource events on `target`.
+     *
+     * @returns a function that removes the listeners.
+     */
+    observe(target) {
+        const onChanged = (event) => {
+            this.handleDataChanged(event.detail);
+        };
+        const onCleared = () => {
+            this.handleDataCleared();
+        };
+        target.addEventListener(datasourceEventNames.dataChanged, onChanged);
+        target.addEventListener(datasourceEventNames.dataCleared, onCleared);
+        return () => {
+            target.removeEventListener(datasourceEventNames.dataChanged, onChanged);
+            target.removeEventListener(datasourceEventNames.dataCleared, onCleared);
+        };
+    }
+    syncRow(row, removed) {
+        var _a;
+        if (!row) {
+            return;
+        }
+        const id = String((_a = row[this.criteria.rowIdField]) !== null && _a !== void 0 ? _a : '');
+        if (!id) {
+            return;
+        }
+        if (removed || !matchesRowCriteria(this.criteria, row)) {
+            this.matchedRowIds.delete(id);
+            return;
+        }
+        this.matchedRowIds.add(id);
+    }
+    report() {
+        const active = this.active;
+        if (active === this.lastReportedActive) {
+            return;
+        }
+        this.lastReportedActive = active;
+        this.onActiveChanged(active);
+    }
+}

package/dist/esm/datasource/row-match.types.js

@@ -0,0 +1,98 @@
+function isEmpty(value) {
+    return value == null || value === '';
+}
+function asFiniteNumber(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    return undefined;
+}
+/**
+ * Equality that tolerates a string criterion against a number or boolean in the row (or the
+ * other way around), so a criteria authored as `'100'` still matches a numeric `100`.
+ */
+function valuesEqual(value, expected) {
+    if (value === expected) {
+        return true;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value) === String(expected);
+    }
+    if (typeof expected === 'number' || typeof expected === 'boolean') {
+        return String(value) === String(expected);
+    }
+    return false;
+}
+function fieldMatches(value, expected, op = '==') {
+    if (expected === null) {
+        if (op === '==') {
+            return isEmpty(value);
+        }
+        if (op === '!=') {
+            return !isEmpty(value);
+        }
+        // Relational ops have no meaning against "empty".
+        return false;
+    }
+    if (op === '==') {
+        return valuesEqual(value, expected);
+    }
+    if (op === '!=') {
+        return !valuesEqual(value, expected);
+    }
+    const left = asFiniteNumber(value);
+    const right = asFiniteNumber(expected);
+    if (left === undefined || right === undefined) {
+        return false;
+    }
+    switch (op) {
+        case '>':
+            return left > right;
+        case '>=':
+            return left >= right;
+        case '<':
+            return left < right;
+        case '<=':
+            return left <= right;
+        default:
+            return false;
+    }
+}
+/** Resolves either criteria form into a single OR-of-AND-groups representation. */
+function resolveRowMatchGroups(criteria) {
+    var _a, _b;
+    if (criteria.anyOf !== undefined) {
+        return criteria.anyOf;
+    }
+    if (criteria.stateField === undefined) {
+        return [];
+    }
+    return [
+        [
+            {
+                field: criteria.stateField,
+                value: (_a = criteria.stateValue) !== null && _a !== void 0 ? _a : null,
+                op: criteria.stateOp,
+            },
+            ...((_b = criteria.and) !== null && _b !== void 0 ? _b : []),
+        ],
+    ];
+}
+/**
+ * True when the row satisfies any resolved AND-group.
+ *
+ * @public
+ */
+export function matchesRowCriteria(criteria, row) {
+    if (!row) {
+        return false;
+    }
+    return resolveRowMatchGroups(criteria).some((group) => group.every((condition) => fieldMatches(row[condition.field], condition.value, condition.op)));
+}

package/dist/esm/grid-pro.styles.js

@@ -1,5 +1,7 @@
+import { alertFlashPhaseProperty } from '@genesislcap/foundation-ui';
 import { css } from '@microsoft/fast-element';
 import { errorHandlerDialogStyles } from './datasource/error-handler.dialog';
+import { ROW_MATCH_ALERT_CELL_CLASS, ROW_MATCH_ALERT_CLASS } from './datasource/row-match.classes';
 import { agExternalStockStyles } from './external';
 /**
  * Workaround for an AG Grid (v36, still present in v36.1.0) drag-ghost positioning bug in
@@ -30,6 +32,51 @@ export const agDragGhostShadowDomStyles = css `
     height: 0;
   }
 `;
+/**
+ * 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 const rowMatchAlertStyles = css `
+  /* The :host prefix is needed to outweigh the AG theme's own .ag-theme-* .ag-row background. */
+  :host .ag-row.${ROW_MATCH_ALERT_CLASS} {
+    background-color: color-mix(
+      in srgb,
+      var(--row-alert-color, var(--error-fill-rest, #c62828))
+        calc(var(${alertFlashPhaseProperty}, 0) * 100%),
+      transparent
+    );
+  }
+
+  /* AG paints cell backgrounds over the row, so they have to stand aside for a row-wide flash. */
+  :host .ag-row.${ROW_MATCH_ALERT_CLASS} .ag-cell:not(.${ROW_MATCH_ALERT_CELL_CLASS}) {
+    background-color: transparent !important;
+  }
+
+  :host .ag-cell.${ROW_MATCH_ALERT_CELL_CLASS} {
+    background-color: color-mix(
+      in srgb,
+      var(--row-alert-color, var(--error-fill-rest, #c62828))
+        calc(var(${alertFlashPhaseProperty}, 0) * 100%),
+      transparent
+    );
+  }
+
+  /* Reduced motion stops the clock, leaving the phase at 0, so paint a steady alert instead. */
+  @media (prefers-reduced-motion: reduce) {
+    :host .ag-row.${ROW_MATCH_ALERT_CLASS}, :host .ag-cell.${ROW_MATCH_ALERT_CELL_CLASS} {
+      background-color: var(--row-alert-color, var(--error-fill-rest, #c62828));
+    }
+  }
+`;
 /**
  * The Grid Pro styles.
  * @public
@@ -39,6 +86,7 @@ export const foundationGridProStyles = css `
   ${agExternalStockStyles}
   ${errorHandlerDialogStyles}
   ${agDragGhostShadowDomStyles}
+  ${rowMatchAlertStyles}
   :host {
     --datasource-error-background-color: var(--neutral-layer-4);
     --datasource-error-background-opacity: 0.5;

package/dist/esm/index.js

@@ -12,6 +12,7 @@ export * from './grid-pro.types';
 export * from './grid-pro';
 export * from './grid-pro-genesis-datasource';
 export * from './multicolumn-dropdown';
+export * from './row-alert';
 export * from './state-persistence';
 export * from './status-bar-components';
 export * from './style';

package/dist/esm/row-alert/index.js

@@ -0,0 +1,2 @@
+export * from './row-alert';
+export * from './row-alert.types';

package/dist/esm/row-alert/row-alert.js

@@ -0,0 +1,197 @@
+import { DI } from '@microsoft/fast-foundation';
+import { createRowMatchCellClassRules, createRowMatchClassRules, ROW_MATCH_ALERT_CELL_CLASS, ROW_MATCH_ALERT_CLASS, } from '../datasource/row-match.classes';
+import { StatePersistence } from '../state-persistence/state-persistence';
+import { logger } from '../utils';
+import { defaultRowAlertColorPresets, defaultRowAlertPreferences, defaultRowAlertRatePresets, defaultRowAlertScopePresets, normalizeRowAlertPreferences, } from './row-alert.types';
+/** CSS variable read by the row flash styles. */
+const ROW_ALERT_COLOR_PROPERTY = '--row-alert-color';
+/** CSS variable read by the shared flash clock, and so by every alerting surface on the page. */
+const ALERT_FLASH_DURATION_PROPERTY = '--alert-flash-duration';
+function resolveStatePersistence(options) {
+    if (options.statePersistence) {
+        return options.statePersistence;
+    }
+    try {
+        return DI.getOrCreateDOMContainer().get(StatePersistence);
+    }
+    catch (error) {
+        logger.debug('Row alert preferences will not persist; no StatePersistence available', error);
+        return undefined;
+    }
+}
+/**
+ * One store per persistence key, so a page whose grids each build their own alert still presents
+ * a single preference: recolouring from one grid's menu is reflected in every other's.
+ */
+const storesByKey = new Map();
+function createPreferenceStore(options) {
+    const { persistPreferencesKey, target, mirrorColorTo = [] } = options;
+    const statePersistence = persistPreferencesKey ? resolveStatePersistence(options) : undefined;
+    const subscribers = new Set();
+    let preferences = normalizeRowAlertPreferences(Object.assign(Object.assign({}, defaultRowAlertPreferences), options.preferences));
+    function applyStyles() {
+        const element = target !== null && target !== void 0 ? target : (typeof document === 'undefined' ? undefined : document.documentElement);
+        if (!element) {
+            return;
+        }
+        element.style.setProperty(ROW_ALERT_COLOR_PROPERTY, preferences.color);
+        element.style.setProperty(ALERT_FLASH_DURATION_PROPERTY, `${preferences.durationMs}ms`);
+        for (const property of mirrorColorTo) {
+            element.style.setProperty(property, preferences.color);
+        }
+    }
+    function apply(next, persist) {
+        preferences = next;
+        applyStyles();
+        for (const subscriber of subscribers) {
+            subscriber(preferences);
+        }
+        if (persist && persistPreferencesKey && (statePersistence === null || statePersistence === void 0 ? void 0 : statePersistence.saveRowAlertPreferences)) {
+            statePersistence
+                .saveRowAlertPreferences(persistPreferencesKey, preferences)
+                .catch((error) => {
+                logger.warn('Could not save row alert preferences', error);
+            });
+        }
+    }
+    applyStyles();
+    if (persistPreferencesKey && (statePersistence === null || statePersistence === void 0 ? void 0 : statePersistence.getRowAlertPreferences)) {
+        statePersistence
+            .getRowAlertPreferences(persistPreferencesKey)
+            .then((stored) => {
+            // Only adopt what was actually stored, so a partial entry keeps the caller's starting
+            // preferences for the rest rather than snapping them back to the library defaults.
+            apply(normalizeRowAlertPreferences(Object.assign(Object.assign({}, preferences), stored)), false);
+        })
+            .catch((error) => {
+            logger.warn('Could not load row alert preferences', error);
+        });
+    }
+    return {
+        get preferences() {
+            return preferences;
+        },
+        change(patch) {
+            apply(normalizeRowAlertPreferences(Object.assign(Object.assign({}, preferences), patch)), true);
+        },
+        subscribe(listener) {
+            subscribers.add(listener);
+            return () => {
+                subscribers.delete(listener);
+            };
+        },
+    };
+}
+function resolvePreferenceStore(options) {
+    const { persistPreferencesKey } = options;
+    if (!persistPreferencesKey) {
+        return createPreferenceStore(options);
+    }
+    let store = storesByKey.get(persistPreferencesKey);
+    if (!store) {
+        store = createPreferenceStore(options);
+        storesByKey.set(persistPreferencesKey, store);
+    }
+    return store;
+}
+/**
+ * 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 function createRowAlert(criteria, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const { colorPresets = defaultRowAlertColorPresets, ratePresets = defaultRowAlertRatePresets, menuLabel = 'Alert flash', } = options;
+    const store = resolvePreferenceStore(options);
+    const rowMatches = createRowMatchClassRules(criteria)[ROW_MATCH_ALERT_CLASS];
+    // Criteria that name no explicit flashField still need one for cell scope to mean anything, and
+    // the field the state is read from is the one that made the row interesting.
+    const cellMatches = createRowMatchCellClassRules(Object.assign(Object.assign({}, criteria), { flashField: (_b = (_a = criteria.flashField) !== null && _a !== void 0 ? _a : criteria.stateField) !== null && _b !== void 0 ? _b : (_e = (_d = (_c = criteria.anyOf) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.field }))[ROW_MATCH_ALERT_CELL_CLASS];
+    function presetItems(presets, selected, change, onChosen) {
+        return presets.map((preset) => ({
+            name: preset.label,
+            checked: preset.value === selected,
+            action: () => {
+                store.change(change(preset.value));
+                onChosen();
+            },
+        }));
+    }
+    const rowAlert = {
+        rowClassRules: {
+            [ROW_MATCH_ALERT_CLASS]: (params) => store.preferences.scope === 'row' && rowMatches(params),
+        },
+        defaultColDef: {
+            cellClassRules: {
+                [ROW_MATCH_ALERT_CELL_CLASS]: (params) => store.preferences.scope === 'cell' && cellMatches(params),
+            },
+        },
+        get preferences() {
+            return store.preferences;
+        },
+        createMenuItem(api) {
+            // Color and rate reach the rows through CSS variables, but scope decides which rule
+            // applies, and rules are only consulted as a row renders.
+            const redrawRows = () => { var _a; return (_a = api === null || api === void 0 ? void 0 : api.redrawRows) === null || _a === void 0 ? void 0 : _a.call(api); };
+            return {
+                name: menuLabel,
+                subMenu: [
+                    {
+                        name: 'Flash target',
+                        subMenu: presetItems(defaultRowAlertScopePresets, store.preferences.scope, (scope) => ({ scope }), redrawRows),
+                    },
+                    {
+                        name: 'Color',
+                        subMenu: presetItems(colorPresets, store.preferences.color, (color) => ({ color }), () => undefined),
+                    },
+                    {
+                        name: 'Flash rate',
+                        subMenu: presetItems(ratePresets, store.preferences.durationMs, (durationMs) => ({ durationMs }), () => undefined),
+                    },
+                    {
+                        name: 'Reset to defaults',
+                        action: () => {
+                            rowAlert.reset();
+                            redrawRows();
+                        },
+                    },
+                ],
+            };
+        },
+        getContextMenuItems(params) {
+            var _a;
+            return [...((_a = params.defaultItems) !== null && _a !== void 0 ? _a : []), 'separator', rowAlert.createMenuItem(params.api)];
+        },
+        setPreferences(patch) {
+            store.change(patch);
+        },
+        reset() {
+            store.change(defaultRowAlertPreferences);
+        },
+        subscribe(listener) {
+            return store.subscribe(listener);
+        },
+    };
+    return rowAlert;
+}

package/dist/esm/row-alert/row-alert.types.js

@@ -0,0 +1,63 @@
+/**
+ * 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 const defaultRowAlertColorPresets = [
+    { id: 'error', label: 'Error', value: 'var(--error-fill-rest, #c62828)' },
+    { id: 'warning', label: 'Warning', value: 'var(--warning-fill-rest, #ef6c00)' },
+    { id: 'success', label: 'Success', value: 'var(--success-fill-rest, #2e7d32)' },
+    { id: 'accent', label: 'Accent', value: 'var(--accent-fill-rest, #1565c0)' },
+    { id: 'neutral', label: 'Neutral', value: 'var(--neutral-fill-rest, #546e7a)' },
+];
+/**
+ * Flash rates offered by default.
+ *
+ * @public
+ */
+export const defaultRowAlertRatePresets = [
+    { id: 'slow', label: 'Slow', value: 1400 },
+    { id: 'normal', label: 'Normal', value: 1000 },
+    { id: 'fast', label: 'Fast', value: 500 },
+];
+/**
+ * Flash targets offered by default. Cell scope only has an effect when the criteria name a
+ * `flashField`.
+ *
+ * @public
+ */
+export const defaultRowAlertScopePresets = [
+    { id: 'row', label: 'Whole row', value: 'row' },
+    { id: 'cell', label: 'Alert field cell', value: 'cell' },
+];
+/**
+ * Where preferences start before a user changes anything.
+ *
+ * @public
+ */
+export const defaultRowAlertPreferences = {
+    color: defaultRowAlertColorPresets[0].value,
+    durationMs: defaultRowAlertRatePresets[1].value,
+    scope: 'row',
+};
+/**
+ * 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 function normalizeRowAlertPreferences(value) {
+    const color = typeof (value === null || value === void 0 ? void 0 : value.color) === 'string' && value.color.trim().length > 0
+        ? value.color
+        : defaultRowAlertPreferences.color;
+    const durationMs = typeof (value === null || value === void 0 ? void 0 : value.durationMs) === 'number' &&
+        Number.isFinite(value.durationMs) &&
+        value.durationMs > 0
+        ? value.durationMs
+        : defaultRowAlertPreferences.durationMs;
+    const scope = (value === null || value === void 0 ? void 0 : value.scope) === 'row' || (value === null || value === void 0 ? void 0 : value.scope) === 'cell'
+        ? value.scope
+        : defaultRowAlertPreferences.scope;
+    return { color, durationMs, scope };
+}

package/dist/esm/state-persistence/kv-state.js

@@ -75,6 +75,27 @@ export class KVStorageStatePersistence {
             ]);
         });
     }
+    getRowAlertPreferences(persistRowAlertKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const kvPreferences = yield this.kvStorage.get(persistRowAlertKey);
+            const storedPreferences = kvPreferences ? (_a = kvPreferences.kv) === null || _a === void 0 ? void 0 : _a.value : undefined;
+            if (storedPreferences) {
+                return JSON.parse(storedPreferences);
+            }
+            return {};
+        });
+    }
+    saveRowAlertPreferences(persistRowAlertKey, preferences) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.kvStorage.put([
+                {
+                    key: persistRowAlertKey,
+                    value: JSON.stringify(preferences),
+                },
+            ]);
+        });
+    }
 }
 __decorate([
     KVStorage

package/dist/esm/state-persistence/local-state.js

@@ -50,6 +50,25 @@ export class LocalStorageStatePersistence {
             this.session.setLocalStorageItem('gridOptions', JSON.stringify(existingOptions));
         });
     }
+    getRowAlertPreferences(persistRowAlertKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const localStorageGridOptions = this.session.getLocalStorageItem('gridOptions');
+            if (localStorageGridOptions) {
+                const allGridOptions = JSON.parse(localStorageGridOptions);
+                if (persistRowAlertKey in allGridOptions) {
+                    return JSON.parse(allGridOptions[persistRowAlertKey]);
+                }
+            }
+            return {};
+        });
+    }
+    saveRowAlertPreferences(persistRowAlertKey, preferences) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingOptions = JSON.parse(this.session.getLocalStorageItem('gridOptions') || '{}');
+            existingOptions[persistRowAlertKey] = JSON.stringify(preferences);
+            this.session.setLocalStorageItem('gridOptions', JSON.stringify(existingOptions));
+        });
+    }
 }
 __decorate([
     Session