Cell Flash

Module Extensions

`CellTemplateProp` (Extended from `@revolist/revogrid`)

1
interface CellTemplateProp {
2
  /**
3
       * Previous value captured when the flash was requested.
4
       */
5
      previousValue?: any;
6
  /**
7
       * Direction resolved by the flash plugin.
8
       */
9
      flashDirection?: CellFlashDirection;
10
  /**
11
       * Active flash state for the rendered cell.
12
       */
13
      flashState?: any
14
}

`ColumnRegular` (Extended from `@revolist/revogrid`)

1
interface ColumnRegular {
2
  /**
3
       * Enables flash feedback for this column.
4
       *
5
       * Legacy `(value) => boolean` predicates are supported. Context-aware
6
       * predicates can inspect the previous value, row model, row type, and edit
7
       * event metadata, and can return a decision object to customize a flash.
8
       *
9
       * @example
10
       * ```ts
11
       * const columns = [
12
       *   { prop: 'name', name: 'Name', flash: value => Boolean(value) },
13
       *   {
14
       *     prop: 'price',
15
       *     name: 'Price',
16
       *     flash: (value, context) => ({
17
       *       flash: value !== context.previousValue,
18
       *       rowFlash: true,
19
       *       direction: Number(value) > Number(context.previousValue) ? 'up' : 'down',
20
       *     }),
21
       *   },
22
       * ];
23
       * ```
24
       */
25
      flash?: CellFlashPredicate
26
}

`HTMLRevoGridElement` (Extended from `@revolist/revogrid`)

1
interface HTMLRevoGridElement {
2
  /**
3
       * Cell flash plugin configuration.
4
       *
5
       * @example
6
       * ```ts
7
       * const grid = document.querySelector('revo-grid');
8
       * grid.plugins = [CellFlashPlugin, EventManagerPlugin];
9
       * grid.cellFlash = {
10
       *   duration: 1200,
11
       *   mode: 'cell-and-row',
12
       *   queue: 'merge',
13
       * };
14
       * ```
15
       */
16
      cellFlash?: CellFlashConfig
17
}

`AdditionalData` (Extended from `@revolist/revogrid`)

1
interface AdditionalData {
2
  /**
3
       * Additional data property for cell flash configuration.
4
       *
5
       * Useful for framework wrappers where all plugin options are passed through
6
       * one memoized or computed `additionalData` object.
7
       *
8
       * @example
9
       * ```tsx
10
       * const additionalData = useMemo(() => ({
11
       *   cellFlash: {
12
       *     duration: 900,
13
       *     mode: 'cell-and-row',
14
       *   },
15
       * }), []);
16
       * ```
17
       */
18
      cellFlash?: CellFlashConfig
19
}

Plugin API

`CellFlashPlugin`

Highlights recently changed cells and rows.

Existing usage with flash: (value) => true, FLASH_CELL_EVENT, and cellFlashArrowTemplate() remains supported. Configure richer behavior through grid.cellFlash or call the instance methods for manual dashboard updates.

Example:

1
* import { CellFlashPlugin, EventManagerPlugin } from '@revolist/revogrid-pro';
2
 *
3
 * const grid = document.querySelector('revo-grid');
4
 * grid.plugins = [CellFlashPlugin, EventManagerPlugin];
5
 * grid.columns = [
6
 *   { prop: 'name', name: 'Name' },
7
 *   { prop: 'price', name: 'Price', flash: value => value !== undefined },
8
 * ];
9
 *
10
 *

Example:

1
* grid.cellFlash = {
2
 *   mode: 'cell-and-row',
3
 *   queue: 'merge',
4
 *   duration: 900,
5
 *   rowDuration: 1400,
6
 *   aria: { enabled: true },
7
 * };
8
 *
9
 *

Example:

1
* grid.columns = [
2
 *   {
3
 *     prop: 'inventory',
4
 *     name: 'Inventory',
5
 *     flash: (value, context) => ({
6
 *       flash: value !== context.previousValue,
7
 *       rowFlash: Number(value) === 0,
8
 *       direction: Number(value) > Number(context.previousValue) ? 'up' : 'down',
9
 *       ariaLabel: `Inventory changed to ${value}`,
10
 *     }),
11
 *   },
12
 * ];

Dependencies

Event integration EventManagerPlugin: Integrates with EventManagerPlugin edit events for automatic edit flashes.
Event integration HistoryPlugin: Integrates with HistoryPlugin undo and redo flash events when present.
Config integration additionalData.cellFlash: Reads cell flash configuration from additionalData.cellFlash.

1
class CellFlashPlugin {
2
  /**
3
     * Flashes one cell manually.
4
     *
5
     * Use this for live-feed updates or external actions that do not come through
6
     * RevoGrid edit events. The method keeps the old event-driven behavior intact
7
     * and only applies an additional manual flash state.
8
     *
9
     * @param target Cell coordinates and optional flash metadata.
10
     *
11
     * @example
12
     * ```ts
13
     * const plugin = grid.getPlugins?.().find(p => p instanceof CellFlashPlugin);
14
     * plugin?.flashCell({
15
     *   rowIndex: 3,
16
     *   prop: 'price',
17
     *   previousValue: 42,
18
     *   value: 45,
19
     *   direction: 'up',
20
     *   duration: 800,
21
     * });
22
     * ```
23
     */
24
  flashCell(target: CellFlashCellTarget);
25

26
  /**
27
     * Flashes a batch of changed cells using the same detail shape as the
28
     * `flashcell` event.
29
     *
30
     * Column `flash` predicates are evaluated for each changed prop. Queue and
31
     * mode options override the configured defaults for this call only.
32
     *
33
     * @param detail Batch detail containing changed values, row type, and optional previous values.
34
     * @param options Optional queue, mode, and duration overrides for this batch.
35
     *
36
     * @example
37
     * ```ts
38
     * plugin.flashCells(
39
     *   {
40
     *     type: 'rgRow',
41
     *     data: { 0: { price: 45, status: 'Updated' } },
42
     *     previousData: { 0: { price: 42, status: 'Draft' } },
43
     *     eventTypes: ['live-feed'],
44
     *   },
45
     *   { queue: 'merge', mode: 'cell-and-row' },
46
     * );
47
     * ```
48
     *
49
     * @example
50
     * ```ts
51
     * grid.dispatchEvent(new CustomEvent('flashcell', {
52
     *   detail: {
53
     *     type: 'rgRow',
54
     *     data: { 1: { price: 50 } },
55
     *     previousData: { 1: { price: 48 } },
56
     *   },
57
     * }));
58
     * ```
59
     */
60
  flashCells(detail: FlashBatchDetail, options?: CellFlashApplyOptions);
61

62
  /**
63
     * Flashes one or more rows manually.
64
     *
65
     * Row flashes are rendered through `beforerowrender`, so virtualized rows keep
66
     * the correct visual state when they re-enter the viewport before expiry.
67
     *
68
     * @param targets One row target or an array of row targets.
69
     * @param options Optional queue, mode, and row duration overrides.
70
     *
71
     * @example
72
     * ```ts
73
     * plugin.flashRows(
74
     *   [
75
     *     { rowIndex: 0, direction: 'changed' },
76
     *     { rowIndex: 4, direction: 'down', rowClassName: 'risk-row-flash' },
77
     *   ],
78
     *   { queue: 'merge', rowDuration: 1200 },
79
     * );
80
     * ```
81
     */
82
  flashRows(targets: CellFlashRowTarget | CellFlashRowTarget[], options?: CellFlashApplyOptions);
83

84
  /**
85
     * Clears active flash state.
86
     *
87
     * Without a target, all active cell and row flashes are cleared. Passing a
88
     * row target clears the row plus all active cell flashes in that row. Passing
89
     * both `rowIndex` and `prop` clears one cell.
90
     *
91
     * @param target Optional cell or row target to clear.
92
     *
93
     * @example
94
     * ```ts
95
     * plugin.clearFlash(); // clear all flashes
96
     * plugin.clearFlash({ rowIndex: 2 }); // clear row 2 and its cell flashes
97
     * plugin.clearFlash({ rowIndex: 2, prop: 'price' }); // clear one cell
98
     * ```
99
     */
100
  clearFlash(target?: Partial<CellFlashCellTarget & CellFlashRowTarget>);
101

102
  destroy();
103
}

`cellFlashArrowTemplate`

1
cellFlashArrowTemplate: (templateOrOptions?: CellTemplate | CellFlashArrowTemplateOptions | undefined, templateOptions?: CellFlashArrowTemplateOptions | undefined) => CellTemplate | undefined;

`resolveCellFlashConfig`

Resolves partial public configuration into the plugin’s internal defaults.

Example:

1
* ```ts
2
 * const config = resolveCellFlashConfig({ duration: 1500, queue: 'merge' });
3
 * console.log(config.mode); // "cell"
4
 * ```

1
export function resolveCellFlashConfig(
2
  config?: CellFlashConfig,
3
): ResolvedCellFlashConfig;

`CellFlashDirection`

Direction metadata attached to an active cell or row flash.

The default resolver returns up or down for numeric changes, changed for non-numeric value changes, and none when no previous value is available.

Example:

1
* ```ts
2
 * const columns = [
3
 *   {
4
 *     prop: 'price',
5
 *     name: 'Price',
6
 *     flash: (value, context) => ({
7
 *       flash: true,
8
 *       direction: Number(value) > Number(context.previousValue) ? 'up' : 'down',
9
 *     }),
10
 *   },
11
 * ];
12
 * ```

1
/**
2
 * Direction metadata attached to an active cell or row flash.
3
 *
4
 * The default resolver returns `up` or `down` for numeric changes,
5
 * `changed` for non-numeric value changes, and `none` when no previous value
6
 * is available.
7
 *
8
 * @example
9
 * ```ts
10
 * const columns = [
11
 *   {
12
 *     prop: 'price',
13
 *     name: 'Price',
14
 *     flash: (value, context) => ({
15
 *       flash: true,
16
 *       direction: Number(value) > Number(context.previousValue) ? 'up' : 'down',
17
 *     }),
18
 *   },
19
 * ];
20
 * ```
21
 */
22
export type CellFlashDirection = 'up' | 'down' | 'changed' | 'none';

`CellFlashMode`

Defines whether flash requests affect cells, rows, or both.

Example:

1
* ```ts
2
 * grid.cellFlash = {
3
 *   mode: 'cell-and-row',
4
 *   rowDuration: 1400,
5
 * };
6
 * ```

1
/**
2
 * Defines whether flash requests affect cells, rows, or both.
3
 *
4
 * @example
5
 * ```ts
6
 * grid.cellFlash = {
7
 *   mode: 'cell-and-row',
8
 *   rowDuration: 1400,
9
 * };
10
 * ```
11
 */
12
export type CellFlashMode = 'cell' | 'row' | 'cell-and-row';

`CellFlashQueueMode`

Controls how new flash requests interact with active flashes.

replace preserves the legacy behavior by clearing existing flashes before applying a new batch. merge keeps existing flashes active until their own timers expire.

Example:

1
* ```ts
2
 * grid.cellFlash = {
3
 *   queue: 'merge',
4
 *   maxActive: 300,
5
 * };
6
 * ```

1
/**
2
 * Controls how new flash requests interact with active flashes.
3
 *
4
 * `replace` preserves the legacy behavior by clearing existing flashes before
5
 * applying a new batch. `merge` keeps existing flashes active until their own
6
 * timers expire.
7
 *
8
 * @example
9
 * ```ts
10
 * grid.cellFlash = {
11
 *   queue: 'merge',
12
 *   maxActive: 300,
13
 * };
14
 * ```
15
 */
16
export type CellFlashQueueMode = 'replace' | 'merge';

`CellFlashContext`

Runtime information passed to context-aware column flash predicates and direction resolvers.

Example:

1
* ```ts
2
 * const columns = [
3
 *   {
4
 *     prop: 'status',
5
 *     name: 'Status',
6
 *     flash: (value, context) => {
7
 *       return context.previousValue !== value && context.eventTypes?.includes('edit');
8
 *     },
9
 *   },
10
 * ];
11
 * ```

1
interface CellFlashContext {
2
  /** New value from the edit/manual flash batch. */
3
    value: unknown;
4
  /** Previous value captured from the event detail or current row model. */
5
    previousValue: unknown;
6
  /** Row index in the target row type. */
7
    rowIndex: number;
8
  /** Column property for the changed cell. */
9
    prop: ColumnProp;
10
  /** Column definition for the changed cell. */
11
    column: ColumnRegular;
12
  /** Current row model, when available from the data provider. */
13
    model?: DataType;
14
  /** RevoGrid row bucket, for example `rgRow`, `rowPinStart`, or `rowPinEnd`. */
15
    type: DimensionRows;
16
  /** Edit/history event type metadata when emitted by EventManagerPlugin. */
17
    eventTypes?: string[];
18
  /** Original flash/edit event detail for advanced consumers. */
19
    detail?: Partial<BeforeRangeSaveDataDetails>
20
}

`CellFlashDecision`

Per-change decision returned from a context-aware column flash predicate.

Returning true is equivalent to { flash: true }. Return a decision object to customize duration, direction, classes, row flashing, or accessibility text for a specific value change.

Example:

1
* ```ts
2
 * const columns = [
3
 *   {
4
 *     prop: 'inventory',
5
 *     name: 'Inventory',
6
 *     flash: (value, context) => ({
7
 *       flash: true,
8
 *       rowFlash: Number(value) === 0,
9
 *       direction: Number(value) > Number(context.previousValue) ? 'up' : 'down',
10
 *       className: Number(value) === 0 ? 'cell-flash-danger' : undefined,
11
 *       ariaLabel: `Inventory changed to ${value}`,
12
 *     }),
13
 *   },
14
 * ];
15
 * ```

1
interface CellFlashDecision {
2
  /** Whether the changed cell should flash. Defaults to true for decision objects. */
3
    flash?: boolean;
4
  /** Whether the containing row should flash for this change. */
5
    rowFlash?: boolean;
6
  /** Cell flash duration in milliseconds for this change. */
7
    duration?: number;
8
  /** Row flash duration in milliseconds for this change. */
9
    rowDuration?: number;
10
  /** Direction metadata for templates, attributes, and CSS selectors. */
11
    direction?: CellFlashDirection;
12
  /** Additional class applied to the flashing cell. */
13
    className?: string;
14
  /** Additional class applied to the flashing row. */
15
    rowClassName?: string;
16
  /** Message announced through the plugin aria-live region when enabled. */
17
    ariaLabel?: string
18
}

`CellFlashPredicate`

Column flash configuration.

Legacy predicates that only accept (value) => boolean still work. New predicates may accept the second CellFlashContext argument and return a CellFlashDecision.

Example:

1
* ```ts
2
 * const columns = [
3
 *   { prop: 'name', name: 'Name', flash: true },
4
 *   {
5
 *     prop: 'price',
6
 *     name: 'Price',
7
 *     flash: (value, context) => ({
8
 *       flash: value !== context.previousValue,
9
 *       direction: Number(value) > Number(context.previousValue) ? 'up' : 'down',
10
 *     }),
11
 *   },
12
 * ];
13
 * ```

1
/**
2
 * Column flash configuration.
3
 *
4
 * Legacy predicates that only accept `(value) = > boolean` still work. New
5
 * predicates may accept the second `CellFlashContext` argument and return a
6
 * `CellFlashDecision`.
7
 *
8
 * @example
9
 * ```ts
10
 * const columns = [
11
 *   { prop: 'name', name: 'Name', flash: true },
12
 *   {
13
 *     prop: 'price',
14
 *     name: 'Price',
15
 *     flash: (value, context) => ({
16
 *       flash: value !== context.previousValue,
17
 *       direction: Number(value) > Number(context.previousValue) ? 'up' : 'down',
18
 *     }),
19
 *   },
20
 * ];
21
 * ```
22
 */
23
export type CellFlashPredicate =
24
  | boolean
25
  | ((value: unknown, context: CellFlashContext) => boolean | CellFlashDecision);

`CellFlashAriaConfig`

Accessibility announcement configuration for cell and row flashes.

Example:

1
* ```ts
2
 * grid.cellFlash = {
3
 *   aria: {
4
 *     enabled: true,
5
 *     label: state => `Row ${state.rowIndex + 1} changed`,
6
 *   },
7
 * };
8
 * ```

1
interface CellFlashAriaConfig {
2
  /** Enables aria-live announcements for flash requests. */
3
    enabled?: boolean;
4
  /** Live-region politeness. Defaults to `polite`. */
5
    live?: 'off' | 'polite' | 'assertive';
6
  /** Controls the `aria-atomic` attribute on the live region. Defaults to true. */
7
    atomic?: boolean;
8
  /** CSS class applied to the generated live region. */
9
    liveRegionClassName?: string;
10
  /** Static label or callback that returns the announcement text. */
11
    label?: string | ((state: CellFlashState) => string)
12
}

`CellFlashLabels`

User-facing labels used by the plugin.

These labels are used for default accessibility announcements. A decision or manual target ariaLabel still has highest priority, followed by aria.label, then these per-kind labels.

Example:

1
* ```ts
2
 * grid.cellFlash = {
3
 *   aria: true,
4
 *   labels: {
5
 *     cellUpdated: state => `Updated ${String(state.prop)} on row ${state.rowIndex + 1}`,
6
 *     rowUpdated: state => `Updated row ${state.rowIndex + 1}`,
7
 *   },
8
 * };
9
 * ```

1
interface CellFlashLabels {
2
  /** Default announcement for cell flashes. */
3
    cellUpdated?: string | ((state: CellFlashState) => string);
4
  /** Default announcement for row flashes. */
5
    rowUpdated?: string | ((state: CellFlashState) => string)
6
}

`CellFlashConfig`

Public plugin configuration accepted by grid.cellFlash and additionalData.cellFlash.

Defaults preserve the original plugin behavior: flashing is enabled, cell-only, lasts 1000ms, replaces active flashes on each event, and clears on source reset.

Example:

1
* ```ts
2
 * grid.plugins = [CellFlashPlugin, EventManagerPlugin];
3
 * grid.cellFlash = {
4
 *   duration: 1200,
5
 *   mode: 'cell-and-row',
6
 *   queue: 'merge',
7
 *   rowClassName: 'price-row-flash',
8
 *   aria: { enabled: true },
9
 *   labels: {
10
 *     cellUpdated: state => `Price cell changed on row ${state.rowIndex + 1}`,
11
 *     rowUpdated: state => `Market row ${state.rowIndex + 1} changed`,
12
 *   },
13
 *   directionResolver: ({ value, previousValue }) => {
14
 *     if (Number(value) > Number(previousValue)) return 'up';
15
 *     if (Number(value) < Number(previousValue)) return 'down';
16
 *     return 'changed';
17
 *   },
18
 * };
19
 * ```

1
interface CellFlashConfig {
2
  /** Enables or disables new flash requests. */
3
    enabled?: boolean;
4
  /** Default cell flash duration in milliseconds. */
5
    duration?: number;
6
  /** Default row flash duration in milliseconds. */
7
    rowDuration?: number;
8
  /** Default flash target mode. */
9
    mode?: CellFlashMode;
10
  /** Default active flash queue behavior. */
11
    queue?: CellFlashQueueMode;
12
  /** Maximum number of active cell and row flashes retained at once. */
13
    maxActive?: number;
14
  /** Clears active flash state when the grid source changes. */
15
    clearOnSourceChange?: boolean;
16
  /** Disables animation when the user prefers reduced motion. */
17
    respectReducedMotion?: boolean;
18
  /** Enables or configures aria-live announcements. */
19
    aria?: boolean | CellFlashAriaConfig;
20
  /** User-facing labels used by default plugin announcements. */
21
    labels?: CellFlashLabels;
22
  /** Base class applied to flashing cells. */
23
    className?: string;
24
  /** Base class applied to flashing rows. */
25
    rowClassName?: string;
26
  /** Optional custom direction resolver used before the default resolver. */
27
    directionResolver?: (context: CellFlashContext) => CellFlashDirection
28
}

`ResolvedCellFlashConfig`

1
interface ResolvedCellFlashConfig {
2
  enabled: boolean;
3
  duration: number;
4
  rowDuration: number;
5
  mode: CellFlashMode;
6
  queue: CellFlashQueueMode;
7
  maxActive: number;
8
  clearOnSourceChange: boolean;
9
  respectReducedMotion: boolean;
10
  aria: Required<Pick<CellFlashAriaConfig, 'enabled' | 'live' | 'atomic' | 'liveRegionClassName'>>
11
      & Pick<CellFlashAriaConfig, 'label'>;
12
  labels: Required<CellFlashLabels>;
13
  className: string;
14
  rowClassName: string;
15
  directionResolver?: (context: CellFlashContext) => CellFlashDirection
16
}

`CellFlashState`

1
interface CellFlashState {
2
  rowIndex: number;
3
  prop?: ColumnProp;
4
  type: DimensionRows;
5
  value?: unknown;
6
  previousValue?: unknown;
7
  direction: CellFlashDirection;
8
  className?: string;
9
  rowClassName?: string;
10
  ariaLabel?: string;
11
  startedAt: number;
12
  duration: number
13
}

`CellFlashCellTarget`

Target accepted by CellFlashPlugin.flashCell().

Example:

1
* ```ts
2
 * const plugin = grid.getPlugins?.().find(p => p instanceof CellFlashPlugin);
3
 * plugin?.flashCell({
4
 *   rowIndex: 0,
5
 *   prop: 'price',
6
 *   previousValue: 42,
7
 *   value: 47,
8
 *   direction: 'up',
9
 * });
10
 * ```

1
interface CellFlashCellTarget {
2
  rowIndex: number;
3
  prop: ColumnProp;
4
  type?: DimensionRows;
5
  value?: unknown;
6
  previousValue?: unknown;
7
  duration?: number;
8
  direction?: CellFlashDirection;
9
  className?: string;
10
  ariaLabel?: string
11
}

`CellFlashRowTarget`

Target accepted by CellFlashPlugin.flashRows().

Example:

1
* ```ts
2
 * const plugin = grid.getPlugins?.().find(p => p instanceof CellFlashPlugin);
3
 * plugin?.flashRows([
4
 *   { rowIndex: 2, direction: 'changed', rowClassName: 'row-flash-warning' },
5
 *   { rowIndex: 5, direction: 'down' },
6
 * ]);
7
 * ```

1
interface CellFlashRowTarget {
2
  rowIndex: number;
3
  type?: DimensionRows;
4
  duration?: number;
5
  direction?: CellFlashDirection;
6
  rowClassName?: string;
7
  ariaLabel?: string
8
}

`CellFlashApplyOptions`

Per-call options for manual and event-driven flash batches.

Example:

1
* ```ts
2
 * plugin.flashCells(
3
 *   { type: 'rgRow', data: { 0: { price: 12 } }, previousData: { 0: { price: 10 } } },
4
 *   { queue: 'merge', mode: 'cell-and-row', duration: 800 },
5
 * );
6
 * ```

1
interface CellFlashApplyOptions {
2
  queue?: CellFlashQueueMode;
3
  mode?: CellFlashMode;
4
  duration?: number;
5
  rowDuration?: number
6
}

`CellFlashTemplatePropExtension`

1
interface CellFlashTemplatePropExtension {
2
  previousValue?: any;
3
  flashDirection?: CellFlashDirection;
4
  flashState?: any
5
}

`CellFlashArrowTemplateOptions`

Options for cellFlashArrowTemplate().

Defaults preserve the original helper output: wrapper class cell-flash, arrow class cell-flash-arrow, up/down/changed direction classes, and ↑ / ↓ symbols.

Example:

1
* ```ts
2
 * cellTemplate: cellFlashArrowTemplate({
3
 *   symbols: { up: '+', down: '-', changed: '~' },
4
 *   className: 'market-flash',
5
 *   arrowClassName: 'market-flash-icon',
6
 *   directionClassNames: { up: 'positive', down: 'negative' },
7
 * })
8
 * ```

1
interface CellFlashArrowTemplateOptions {
2
  /** Direction symbols rendered before the cell content. */
3
    symbols?: Partial<Record<CellFlashDirection, string>>;
4
  /** Wrapper class applied around the arrow and cell content. */
5
    className?: string;
6
  /** Class applied to the symbol element. */
7
    arrowClassName?: string;
8
  /** Direction-specific wrapper classes. */
9
    directionClassNames?: Partial<Record<CellFlashDirection, string>>
10
}

`CellFlashTemplateParams` (Extended from `index.ts`)

1
export type CellFlashTemplateParams = CellTemplateProp & CellFlashTemplatePropExtension;

Cell Flash

Module Extensions

CellTemplateProp (Extended from @revolist/revogrid)

ColumnRegular (Extended from @revolist/revogrid)

HTMLRevoGridElement (Extended from @revolist/revogrid)

AdditionalData (Extended from @revolist/revogrid)

Plugin API

CellFlashPlugin

Dependencies

cellFlashArrowTemplate

resolveCellFlashConfig

CellFlashDirection

CellFlashMode

CellFlashQueueMode

CellFlashContext

CellFlashDecision

CellFlashPredicate

CellFlashAriaConfig

CellFlashLabels

CellFlashConfig

ResolvedCellFlashConfig

CellFlashState

CellFlashCellTarget

CellFlashRowTarget

CellFlashApplyOptions

CellFlashTemplatePropExtension

CellFlashArrowTemplateOptions

CellFlashTemplateParams (Extended from index.ts)

`CellTemplateProp` (Extended from `@revolist/revogrid`)

`ColumnRegular` (Extended from `@revolist/revogrid`)

`HTMLRevoGridElement` (Extended from `@revolist/revogrid`)

`AdditionalData` (Extended from `@revolist/revogrid`)

`CellFlashPlugin`

`cellFlashArrowTemplate`

`resolveCellFlashConfig`

`CellFlashDirection`

`CellFlashMode`

`CellFlashQueueMode`

`CellFlashContext`

`CellFlashDecision`

`CellFlashPredicate`

`CellFlashAriaConfig`

`CellFlashLabels`

`CellFlashConfig`

`ResolvedCellFlashConfig`

`CellFlashState`

`CellFlashCellTarget`

`CellFlashRowTarget`

`CellFlashApplyOptions`

`CellFlashTemplatePropExtension`

`CellFlashArrowTemplateOptions`

`CellFlashTemplateParams` (Extended from `index.ts`)