Data Grid Formatting

Module Extensions

`DataGridAdvancedFormatsConfig`

1
interface DataGridAdvancedFormatsConfig {
2
  /** Disable or override individual built-ins by stable id. */
3
    readonly formats?: Readonly<Record<
4
      string,
5
      false | DataGridAdvancedFormatOverride
6
    >>;
7
  /** Application formats appended to the built-in catalog. */
8
    readonly customFormats?: readonly DataGridAdvancedFormatDefinition[];
9
  /** Optional editors for ordinary value presets such as `date`. */
10
    readonly presetEditors?: Partial<Record<
11
      DataGridValueFormatPreset,
12
      false | EditorCtr | string
13
    >>;
14
  /** Allow presentations to replace application cell templates globally. */
15
    readonly replaceAuthoredTemplates?: boolean;
16
  /** Allow format-resolved editors to replace application editors globally. */
17
    readonly replaceAuthoredEditors?: boolean
18
}

`HTMLRevoGridElementEventMap` (Extended from `global`)

1
interface HTMLRevoGridElementEventMap {
2
  [DATA_GRID_FORMATTING_CONFIGURATION_CHANGE_EVENT]: Readonly<DataGridFormattingConfig>
3
}

`HTMLRevoGridElement` (Extended from `global`)

1
interface HTMLRevoGridElement {
2
  /** Reactive declarative formats consumed by DataGridFormattingPlugin. */
3
      dataGridFormatting?: DataGridFormattingPresetState;
4
  'data-grid-formatting'?: DataGridFormattingPresetState
5
}

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

1
interface ColumnRegular {
2
  /** Static or cell-resolved declarative Format Cells configuration. */
3
      dataGridFormat?: DataGridFormatDefinition<TModel, P>
4
}

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

1
interface AdditionalData {
2
  /** @deprecated Prefer `grid.dataGridFormatting`. */
3
      dataGridFormatting?: DataGridFormattingPresetState
4
}

Plugin API

`DataGridFormattingPluginOptions`

@internal Coordinates reciprocal plugin installation.

1
interface DataGridFormattingPluginOptions {
2
  readonly installContextMenu?: boolean;
3
  readonly installPanel?: boolean
4
}

`DataGridFormattingPlugin`

Spreadsheet-style value, visual presentation, appearance, and editor configuration for RevoGrid cells, rows, and columns.

Register this plugin once in grid.plugins. It installs the task-oriented data-grid context menu, Format Cells dialog, and visual-format tooltips automatically. It also installs the formatting-panel runtime; set grid.dataGridFormattingPanel = true to show the opt-in toolbar. Formatting can then be declared through column.dataGridFormat or grid.dataGridFormatting, inferred from a registered renderer assigned to column.cellTemplate, or changed at runtime through this plugin’s API. Source values are never modified.

Numeric values and numeric presets are right-aligned automatically. Set appearance.horizontal to left, center, or right to override it. Configure autoAlignNumericValues: false to disable this derived alignment. Effective advanced presentations retain their own layout unless an explicit horizontal alignment is authored.

Example: Declarative column, row, and cell formatting

1
import type { ColumnRegular } from '@revolist/revogrid';
2
import {
3
  DataGridFormattingPlugin,
4
  type DataGridCellFormat,
5
} from '@revolist/revogrid-pro';
6

7
type InvoiceRow = { id: string; customer: string; amount: number };
8

9
const money: DataGridCellFormat = {
10
  value: {
11
    preset: 'currency',
12
    locale: 'en-GB',
13
    currency: 'GBP',
14
    decimalPlaces: 2,
15
  },
16
};
17

18
const columns: ColumnRegular<string, InvoiceRow>[] = [
19
  { prop: 'customer', name: 'Customer' },
20
  { prop: 'amount', name: 'Amount', dataGridFormat: money },
21
];
22

23
grid.plugins = [DataGridFormattingPlugin];
24
grid.columns = columns;
25
grid.dataGridFormatting = {
26
  rows: [{ row: 0, format: { appearance: { bold: true } } }],
27
  cells: [{ range: { start: { row: 1, column: 1 } }, format: {
28
    ...money,
29
    appearance: { ...money.appearance, bold: true, fillColor: '#fef3c7' },
30
  } }],
31
};
32
grid.source = [
33
  { id: 'invoice-1', customer: 'Acme Ltd', amount: 1200 },
34
  { id: 'invoice-2', customer: 'Northwind', amount: -350.5 },
35
];

Example: Save and restore application-owned formatting state

1
const saved = loadFormatting();
2

3
grid.plugins = [DataGridFormattingPlugin];
4
grid.dataGridFormatting = {
5
  state: saved,
6
};
7
grid.addEventListener('datagridformattingchange', ({ detail }) => {
8
  saveFormatting(detail.state);
9
});

Example: Configure advanced formats and application-owned editors

1
import DateColumnType from '@revolist/revogrid-column-date';
2
import {
3
  DataGridFormattingPlugin,
4
  type DataGridFormattingConfig,
5
} from '@revolist/revogrid-pro';
6

7
const dateType = new DateColumnType();
8
const formatting: DataGridFormattingConfig = {
9
  advancedFormats: {
10
    // Compatible built-ins are enabled unless explicitly disabled.
11
    formats: {
12
      pie: false,
13
      heatmap: { defaults: { minValue: 0, maxValue: 100 } },
14
    },
15
    // Editor packages stay optional and are supplied by the application.
16
    presetEditors: { date: dateType.editor },
17
  },
18
};
19

20
grid.plugins = [DataGridFormattingPlugin];
21
grid.dataGridContextMenu = { formatting };
22
grid.columns = [{
23
  prop: 'completion',
24
  name: 'Completion',
25
  dataGridFormat: {
26
    presentation: {
27
      id: 'progress-line',
28
      options: { minValue: 0, maxValue: 100 },
29
    },
30
  },
31
}];

Dependencies

Auto-installed EventManagerPlugin: Normalizes edits and paste operations through the unified grid edit pipeline.
Auto-installed AutoFillPlugin: Generates spreadsheet-style value sequences while formatting follows the filled range.
Auto-installed ClipboardPlugin: Provides rich Excel-compatible clipboard formatting.
Auto-installed DataGridFormatDialogPlugin: Uses the Format Cells dialog for advanced formatting.
Optional FormulaPlugin: Formats evaluated formula results while preserving raw formula source values.
Auto-installed DataGridContextMenuPlugin: Provides Format Cells commands through the task-oriented data-grid context menu.
Auto-installed TooltipPlugin: Displays details for visual-format parts such as Timeline events.
Auto-installed DataGridFormattingPanelPlugin: Provides the opt-in single-row formatting toolbar runtime.

1
class DataGridFormattingPlugin {
2
  /**
3
     * Replace the runtime options used by dialog and programmatic formatting.
4
     *
5
     * Context-menu applications can set the same options reactively through
6
     * `grid.dataGridContextMenu.formatting`.
7
     *
8
     * @param config Locale, dialog, value-kind, advanced-format,
9
     * and optional editor settings.
10
     */
11
  configure(config: DataGridFormattingConfig<T> = {}): void;
12

13
  /** Return the active formatting options used by the dialog and toolbar. */
14
  getConfiguration(): Readonly<DataGridFormattingConfig<T>>;
15

16
  /** Convert safe Excel HTML declarations into canonical formatting options. */
17
  importExcelClipboardFormat(
18
    declarations: readonly string[],
19
  ): DataGridCellFormat | undefined;
20

21
  /** Convert display-only Excel HTML text using its canonical imported format. */
22
  importExcelClipboardValue(displayText: string, format?: DataGridCellFormat): unknown;
23

24
  /** Convert canonical formatting options into Excel-compatible HTML declarations. */
25
  exportExcelClipboardFormat(format: DataGridCellFormat): string | undefined;
26

27
  /** Convert a source value into the typed/display pair written to Excel HTML. */
28
  exportExcelClipboardValue(value: unknown, format: DataGridCellFormat);
29

30
  /**
31
     * Apply a complete value, advanced-presentation, and appearance format to a
32
     * physical cell, complete-row, or complete-column selection. This runtime format takes precedence over
33
     * declarative presets.
34
     *
35
     * @param target Physical cell, complete-row, or complete-column source coordinates to format.
36
     * @param format Complete format to apply.
37
     */
38
  apply(target: DataGridFormattingTarget, format: DataGridCellFormat): void;
39

40
  /** @internal Applies one clipboard/import batch with a single refresh and change event. */
41
  applyBatch(entries: readonly {
42
    target: DataGridFormattingTarget;
43
    /** `null` records an explicit clipboard clear for the target. */
44
    format: DataGridCellFormat | null;
45
  }[]): void;
46

47
  /** @internal Applies accepted autofill formatting as one runtime mutation. */
48
  applyAutofillBatch(entries: readonly AutofillFormattingBatchEntry[]): void;
49

50
  /**
51
     * Select an ordinary value presentation while retaining font, fill,
52
     * alignment, and other appearance settings. A concrete value presentation
53
     * replaces any active advanced visualization for the same target.
54
     *
55
     * @param target Physical cell, complete-row, or complete-column source coordinates to format.
56
     * @param value Value-format layer to apply.
57
     */
58
  applyValueFormat(
59
    target: DataGridFormattingTarget,
60
    value: DataGridCellFormat['value'],
61
  ): void;
62

63
  /**
64
     * Patch selected formats without erasing unrelated value, appearance, or
65
     * presentation settings. A resolver can return a different patch per cell.
66
     */
67
  patch(
68
    target: DataGridFormattingTarget,
69
    patch: DataGridCellFormatPatch | DataGridFormattingPatchResolver<T>,
70
  ): void;
71

72
  /**
73
     * Clear runtime formatting for a physical cell selection without changing
74
     * source values. The explicit clear suppresses lower-priority declarative
75
     * formatting for that target.
76
     *
77
     * @param target Physical cell, complete-row, or complete-column source coordinates to clear.
78
     */
79
  clear(target: DataGridFormattingTarget): void;
80

81
  /**
82
     * Return the effective format for a cell after runtime and
83
     * declarative precedence has been resolved.
84
     *
85
     * @param address Physical source address of the cell.
86
     * @returns The effective format, or `undefined` when no format applies.
87
     */
88
  getFormat(address: PhysicalCellAddress): DataGridCellFormat | undefined;
89

90
  /** Return the effective coordinate-owned format for a complete column. */
91
  getColumnFormat(address: PhysicalColumnAddress): DataGridCellFormat | undefined;
92

93
  /** Return the coordinate-owned format for a complete row. */
94
  getRowFormat(address: PhysicalRowAddress): DataGridCellFormat | undefined;
95

96
  /**
97
     * Return the effective built-in, overridden, or application-defined advanced
98
     * format definition by its stable presentation id.
99
     *
100
     * Export integrations use this to apply presentation-owned scalar export
101
     * values without inspecting rendered cells.
102
     */
103
  getAdvancedFormatDefinition(id: string): DataGridAdvancedFormatDefinition | undefined;
104

105
  /**
106
     * Return a portable snapshot of coordinate-owned runtime operations.
107
     */
108
  getState(): DataGridFormattingRuntimeState;
109

110
  /**
111
     * Replace runtime Apply and Clear operations from a previous `getState()`
112
     * snapshot, refresh the grid, and emit `datagridformattingchange`.
113
     */
114
  setState(state: DataGridFormattingRuntimeState): void;
115

116
  /** @internal Replays a formatting state from HistoryPlugin. */
117
  applyHistoryState(state: DataGridFormattingRuntimeState): boolean;
118

119
  /** @internal Called by HistoryPlugin around an atomic structural snapshot replay. */
120
  beginHistoryStructureReplay(): void;
121

122
  /** @internal Called by HistoryPlugin after formatting and structure are both restored. */
123
  endHistoryStructureReplay(): void;
124

125
  /** @internal Keeps partial structural commands inside their History transaction. */
126
  flushPendingStructuralTransaction(transactionId: number): void;
127

128
  /**
129
     * Open the Format Cells dialog for a selection. Context-menu users do not
130
     * need to call this method directly.
131
     *
132
     * @param target Physical cells, complete rows, or complete columns to edit.
133
     * @param valueKind Value category used to choose available presets.
134
     * @param valueFormatting Set to `false` for appearance-only editing.
135
     */
136
  openDialog(
137
    target: DataGridFormattingTarget,
138
    valueKind: DataGridFormattingValueKind,
139
    valueFormatting = true,
140
  ): void;
141

142
  /** Return the effective value kind, including evaluated formula results. */
143
  inferValueKind(target: DataGridFormattingTarget): DataGridFormattingValueKind;
144

145
  resolveCellValue(
146
    model: T,
147
    column: ColumnRegular,
148
    rowType?: DimensionRows,
149
    value: unknown = model[column.prop],
150
  ): unknown;
151
}

`isDataGridFormattingRuntime`

1
export function isDataGridFormattingRuntime(
2
  value: unknown,
3
): value is DataGridFormattingRuntime;

`DATA_GRID_FORMATTING_PLUGIN`

1
DATA_GRID_FORMATTING_PLUGIN: string;

`DATA_GRID_FORMATTING_CHANGE_EVENT`

1
DATA_GRID_FORMATTING_CHANGE_EVENT: string;

`DATA_GRID_FORMATTING_CONFIGURATION_CHANGE_EVENT`

1
DATA_GRID_FORMATTING_CONFIGURATION_CHANGE_EVENT: string;

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

1
interface DataGridFormattingRuntime {
2
  readonly [DATA_GRID_FORMATTING_PLUGIN]: true;
3
  getFormat(address: PhysicalCellAddress): DataGridCellFormat | undefined;
4
  getColumnFormat(address: PhysicalColumnAddress): DataGridCellFormat | undefined;
5
  getRowFormat(address: PhysicalRowAddress): DataGridCellFormat | undefined;
6
  getAdvancedFormatDefinition(id: string): DataGridAdvancedFormatDefinition | undefined;
7
  getState(): DataGridFormattingRuntimeState;
8
  apply(target: DataGridFormattingTarget, format: DataGridCellFormat): void;
9
  applyBatch(entries: readonly {
10
      target: DataGridFormattingTarget;
11
      format: DataGridCellFormat | null;
12
    }[]): void;
13
  importExcelClipboardFormat(declarations: readonly string[]): DataGridCellFormat | undefined;
14
  importExcelClipboardValue(displayText: string, format?: DataGridCellFormat): unknown;
15
  exportExcelClipboardFormat(format: DataGridCellFormat): string | undefined;
16
  exportExcelClipboardValue(
17
      value: unknown,
18
      format: DataGridCellFormat,
19
    ): DataGridExcelClipboardValue;
20
  resolveCellValue(
21
      model: DataType,
22
      column: ColumnRegular,
23
      rowType?: DimensionRows,
24
      value?: unknown,
25
    ): unknown
26
}

`DataGridExcelClipboardValue`

1
interface DataGridExcelClipboardValue {
2
  /** Typed value written to Excel HTML. Source data is never mutated. */
3
    readonly value: unknown;
4
  /** Canonically formatted text shown by Excel before/recalculation. */
5
    readonly displayText: string
6
}

`resolveDataGridFormattingLocale`

1
export function resolveDataGridFormattingLocale(
2
  localeText?: DataGridFormattingDialogConfig['localeText'],
3
): DataGridFormattingLocaleText;

`DATA_GRID_FORMATTING_LOCALE`

1
DATA_GRID_FORMATTING_LOCALE: {
2
  title: string;
3
  close: string;
4
  description: string;
5
  selectionSummary: string;
6
  selectionCells: string;
7
  selectionColumns: string;
8
  valueSection: string;
9
  automaticDescription: string;
10
  advancedSection: string;
11
  advancedNone: string;
12
  advancedDescription: string;
13
  numberSection: string;
14
  category: string;
15
  locale: string;
16
  browserDefault: string;
17
  decimals: string;
18
  grouping: string;
19
  currency: string;
20
  negativeNumbers: string;
21
  dateStyle: string;
22
  timeStyle: string;
23
  custom: string;
24
  formatCode: string;
25
  invalidFormatCode: string;
26
  fontSection: string;
27
  typographySection: string;
28
  colorsSection: string;
29
  fontFamily: string;
30
  defaultFont: string;
31
  fontSize: string;
32
  bold: string;
33
  italic: string;
34
  underline: string;
35
  strike: string;
36
  textColor: string;
37
  fillColor: string;
38
  useTextColor: string;
39
  useFillColor: string;
40
  defaultColor: string;
41
  noFill: string;
42
  customColor: string;
43
  customColorHex: string;
44
  invalidColor: string;
45
  colorLabels: { [k: string]: string; };
46
  advancedGroupLabels: { Advanced: string; Indicators: string; Charts: string; Values: string; Identity: string; Summaries: string; };
47
  advancedFormatLabels: { 'progress-line': string; 'progress-line-value': string; 'circular-progress': string; heatmap: string; rating: string; change: string; threshold: string; boolean: string; thumbs: string; badge: string; sparkline: string; bar: string; pie: string; timeline: string; avatar: string; 'avatar-with-text': string; 'summary-percentage': string; 'summary-aggregate': string; };
48
  advancedFormatDescriptions: { 'progress-line': string; 'progress-line-value': string; threshold: string; };
49
  advancedControlLabels: { 'progress-line.minValue': string; 'progress-line.maxValue': string; 'progress-line-value.minValue': string; 'progress-line-value.maxValue': string; 'circular-progress.minValue': string; 'circular-progress.maxValue': string; 'circular-progress.showValue': string; 'heatmap.minValue': string; 'heatmap.midValue': string; 'heatmap.maxValue': string; 'heatmap.lowColor': string; 'heatmap.midColor': string; 'heatmap.highColor': string; 'rating.maxStars': string; 'badge.rectangular': string; 'sparkline.minValue': string; 'sparkline.maxValue': string; 'bar.minValue': string; 'bar.maxValue': string; 'bar.barPosition': string; 'avatar.avatarSize': string; 'avatar.rectangular': string; 'avatar-with-text.avatarSize': string; 'avatar-with-text.rectangular': string; 'summary-percentage.maxItems': string; 'summary-aggregate.showSum': string; 'summary-aggregate.showAvg': string; };
50
  advancedOptionLabels: { 'bar.barPosition.bottom': string; 'bar.barPosition.top': string; };
51
  expandSection: string;
52
  collapseSection: string;
53
  alignmentSection: string;
54
  horizontal: string;
55
  vertical: string;
56
  wrap: string;
57
  borderSection: string;
58
  borderStyle: string;
59
  borderColor: string;
60
  preview: string;
61
  previewOriginal: string;
62
  previewFormatted: string;
63
  previewHint: string;
64
  clear: string;
65
  cancel: string;
66
  apply: string;
67
  textExample: string;
68
  presetLabels: { automatic: string; number: string; currency: string; accounting: string; percent: string; scientific: string; date: string; datetime: string; time: string; text: string; };
69
  optionLabels: { automatic: string; left: string; center: string; right: string; top: string; middle: string; bottom: string; none: string; solid: string; dashed: string; dotted: string; double: string; short: string; medium: string; long: string; full: string; negativeMinus: string; negativeRed: string; negativeParentheses: string; };
70
  dataEditor: { chartTitle: string; timelineTitle: string; close: string; preview: string; pointSummary: string; pointsSummary: string; eventSummary: string; eventsSummary: string; value: string; pointValue: string; label: string; start: string; end: string; eventLabel: string; eventStart: string; eventEnd: string; addPoint: string; addEvent: string; deletePoint: string; deleteEvent: string; reorderPoint: string; moveEvent: string; reorderEvent: string; pasteValues: string; pasteHint: string; replaceValues: string; appendValues: string; editRawJson: string; visualEditor: string; rawJsonHint: string; invalidNumber: string; invalidPaste: string; invalidTimeline: string; invalidJson: string; outsideRange: string; emptyPoints: string; emptyEvents: string; cancel: string; apply: string; validationSummary: string; resizeStart: string; resizeEnd: string; };
71
};

`DataGridFormatDialogPlugin`

Dependencies

Auto-installed DialogPlugin: Uses the shared Pro dialog runtime for Format Cells.

1
class DataGridFormatDialogPlugin {
2
  open(options: DataGridFormattingDialogOpenOptions<T>): void;
3

4
  close(): void;
5
}

`createDataGridFormattingEditor`

1
export function createDataGridFormattingEditor(
2
  document: Document,
3
  options: DataGridFormattingDialogOpenOptions,
4
  locale: DataGridFormattingLocaleText,
5
): DataGridFormattingEditor;

`DataGridFormattingEditor`

1
interface DataGridFormattingEditor {
2
  readonly element: HTMLElement;
3
  readonly preview: HTMLElement;
4
  readonly descriptionId: string;
5
  getDraft(): DataGridCellFormat;
6
  isValid(): boolean;
7
  onValidityChange(listener: (valid: boolean) => void): () => void;
8
  destroy(): void
9
}

`importDataGridExcelClipboardFormat`

Convert raw Excel HTML declarations into the canonical formatting options. Clipboard codecs deliberately do not interpret or render these declarations.

1
export function importDataGridExcelClipboardFormat(
2
  declarations: readonly string[],
3
): DataGridCellFormat | undefined;

`exportDataGridExcelClipboardFormat`

Convert canonical formatting options into the Excel HTML representation.

1
export function exportDataGridExcelClipboardFormat(
2
  format: DataGridCellFormat,
3
): string | undefined;

`exportDataGridExcelClipboardValue`

Convert a raw value into Excel HTML’s typed value plus canonical display.

1
export function exportDataGridExcelClipboardValue(
2
  value: unknown,
3
  format: DataGridCellFormat,
4
);

`createDataGridExcelNumberFormat`

Map canonical value-format options to one native Excel number-format code.

1
export function createDataGridExcelNumberFormat(
2
  format: import('../types').DataGridValueFormat,
3
): string | undefined;

`importDataGridExcelClipboardValue`

Convert display-only Excel HTML text into a canonical typed value.

1
export function importDataGridExcelClipboardDisplayValue(
2
  displayText: string,
3
  format?: DataGridCellFormat,
4
): unknown;

`resolveDataGridAdvancedFormats`

1
export function resolveDataGridAdvancedFormats(
2
  config?: false | DataGridAdvancedFormatsConfig,
3
): readonly DataGridAdvancedFormatDefinition[];

`compatibleDataGridAdvancedFormats`

1
export function compatibleDataGridAdvancedFormats<T extends DataType>(
2
  definitions: readonly DataGridAdvancedFormatDefinition[],
3
  selection: DataGridFormattingResolvedSelection<T>,
4
  fallbackKind: DataGridFormattingValueKind = 'unknown',
5
  resolveValue?: (context: DataGridAdvancedFormatCompatibilityContext) => unknown,
6
): readonly DataGridAdvancedFormatDefinition[];

`isDataGridAdvancedFormatCompatible`

1
export function isDataGridAdvancedFormatCompatible(
2
  definition: DataGridAdvancedFormatDefinition,
3
  context: DataGridAdvancedFormatCompatibilityContext,
4
): boolean;

`findDataGridAdvancedFormat`

1
export function findDataGridAdvancedFormat(
2
  definitions: readonly DataGridAdvancedFormatDefinition[],
3
  id: string | undefined,
4
): DataGridAdvancedFormatDefinition | undefined;

`resolveDataGridRendererFormat`

Resolve the authored advanced-format baseline advertised by a cell renderer.

1
export function resolveDataGridRendererFormat(
2
  definitions: readonly DataGridAdvancedFormatDefinition[],
3
  column: ColumnRegular | undefined,
4
): DataGridCellFormat | undefined;

`dataGridAdvancedAppearanceColorStyle`

Map generic appearance colors either to the cell or renderer-owned variables.

1
export function dataGridAdvancedAppearanceColorStyle(
2
  appearance: DataGridCellFormat['appearance'],
3
  definition?: DataGridAdvancedFormatDefinition,
4
  textColor = appearance?.textColor,
5
): Record<string, string | undefined>;

`DATA_GRID_BUILT_IN_ADVANCED_FORMATS`

Cell-capable visualizations shipped with RevoGrid Pro.

1
DATA_GRID_BUILT_IN_ADVANCED_FORMATS: readonly DataGridAdvancedFormatDefinition[];

`createDataGridValueFormat`

1
export function createDataGridValueFormat(
2
  preset: DataGridValueFormatPreset,
3
  locale?: string,
4
  currency = 'USD',
5
): DataGridCellFormat;

`createDataGridCodeFormat`

1
export function createDataGridCodeFormat(
2
  formatCode: string,
3
  locale?: string,
4
): DataGridCellFormat;

`isDataGridPresetValueFormat`

1
export function isDataGridPresetValueFormat(
2
  format: DataGridValueFormat | undefined,
3
): format is DataGridPresetValueFormat;

`isDataGridCodeValueFormat`

1
export function isDataGridCodeValueFormat(
2
  format: DataGridValueFormat | undefined,
3
): format is DataGridCodeValueFormat;

`inferDataGridFormattingKind`

1
export function inferDataGridFormattingKind<T extends DataType>(
2
  selection: DataGridFormattingResolvedSelection<T>,
3
  columnTypeKinds: Readonly<Record<string, DataGridFormattingValueKind>> = {},
4
  resolveValue: DataGridFormattingValueResolver<T> = ({ model, column }) => model[column.prop],
5
): DataGridFormattingValueKind;

`formatDataGridValue`

1
export function formatDataGridValue(
2
  value: unknown,
3
  format?: DataGridValueFormat,
4
): string;

`formatDataGridExcelCode`

Formats the common Excel custom-number-code families used by HTML clipboard data.

1
export function formatDataGridExcelCode(value: unknown, code: string): string;

`classifyDataGridValueFormat`

1
export function classifyDataGridValueFormat(format?: DataGridValueFormat);

`formatDataGridAutomaticValue`

Readable default display for scalar and structured values.

1
export function formatDataGridAutomaticValue(value: unknown): string;

`isDataGridNumberPreset`

1
export function isDataGridNumberPreset(preset: DataGridValueFormatPreset): boolean;

`isDataGridDatePreset`

1
export function isDataGridDatePreset(preset: DataGridValueFormatPreset): boolean;

`normalizeDataGridLocale`

1
export function normalizeDataGridLocale(locale?: string): string | undefined;

`normalizeDataGridCurrency`

1
export function normalizeDataGridCurrency(currency?: string): string;

`toDataGridDate`

1
export function toDataGridDate(value: unknown): Date | undefined;

`DataGridFormattingValueResolver`

1
export type DataGridFormattingValueResolver<T extends DataType = DataType> = (
2
  cell: DataGridFormattingCell<T>,
3
) => unknown;

`compileDataGridFormatCode`

1
export function compileDataGridFormatCode(code: string): ParsedDataGridFormatCode;

`validateDataGridFormatCode`

1
export function validateDataGridFormatCode(code: string): readonly DataGridFormatCodeDiagnostic[];

`formatDataGridCodeValue`

1
export function formatDataGridCodeValue(
2
  value: unknown,
3
  code: string,
4
  locale?: string,
5
): DataGridFormattedCodeValue;

`classifyDataGridCodeValue`

1
export function classifyDataGridCodeValue(code: string);

`getDataGridFormatCodeCacheSize`

@internal Test hook for proving bounded cache behavior.

1
export function getDataGridFormatCodeCacheSize();

`MAX_DATA_GRID_FORMAT_CODE_LENGTH`

1
MAX_DATA_GRID_FORMAT_CODE_LENGTH: 4096;

`DataGridFormatCodeValueKind`

1
export type DataGridFormatCodeValueKind = 'number' | 'date' | 'time' | 'text' | 'automatic';

`DataGridFormatCodeDiagnostic`

1
interface DataGridFormatCodeDiagnostic {
2
  readonly index: number;
3
  readonly message: string
4
}

`DataGridFormatCodeSegment`

1
export type DataGridFormatCodeSegment =
2
  | { readonly kind: 'text'; readonly value: string }
3
  | { readonly kind: 'space'; readonly character: string }
4
  | { readonly kind: 'fill'; readonly character: string };

`DataGridFormattedCodeValue`

1
interface DataGridFormattedCodeValue {
2
  readonly text: string;
3
  readonly color?: string;
4
  readonly kind: DataGridFormatCodeValueKind;
5
  readonly segments: readonly DataGridFormatCodeSegment[]
6
}

`DataGridFormatCodeConditionOperator`

1
export type DataGridFormatCodeConditionOperator = '<' | '<=' | '>' | '>=' | '=' | '<>';

`DataGridFormatCodeCondition`

1
interface DataGridFormatCodeCondition {
2
  readonly operator: DataGridFormatCodeConditionOperator;
3
  readonly value: number
4
}

`DataGridFormatCodeToken`

1
export type DataGridFormatCodeToken =
2
  | { readonly kind: 'literal'; readonly value: string }
3
  | { readonly kind: 'placeholder'; readonly value: string }
4
  | { readonly kind: 'decimal' }
5
  | { readonly kind: 'comma' }
6
  | { readonly kind: 'percent' }
7
  | { readonly kind: 'fraction' }
8
  | { readonly kind: 'exponent'; readonly value: string }
9
  | { readonly kind: 'date'; readonly symbol: 'y' | 'm' | 'd' | 'h' | 's'; readonly length: number }
10
  | { readonly kind: 'elapsed'; readonly symbol: 'h' | 'm' | 's'; readonly length: number }
11
  | { readonly kind: 'ampm'; readonly short: boolean }
12
  | { readonly kind: 'text' }
13
  | { readonly kind: 'general' }
14
  | { readonly kind: 'space'; readonly character: string }
15
  | { readonly kind: 'fill'; readonly character: string }
16
  | { readonly kind: 'currency'; readonly symbol: string; readonly localeId?: string };

`ParsedDataGridFormatCodeSection`

1
interface ParsedDataGridFormatCodeSection {
2
  readonly tokens: readonly DataGridFormatCodeToken[];
3
  readonly condition?: DataGridFormatCodeCondition;
4
  readonly color?: string
5
}

`ParsedDataGridFormatCode`

1
interface ParsedDataGridFormatCode {
2
  readonly code: string;
3
  readonly sections: readonly ParsedDataGridFormatCodeSection[];
4
  readonly diagnostics: readonly DataGridFormatCodeDiagnostic[]
5
}

`resolveDataGridFormatCodeLocale`

1
export function resolveDataGridFormatCodeLocale(
2
  parsed: ParsedDataGridFormatCode,
3
): string | undefined;

`resolveDataGridFormatSectionLocale`

1
export function resolveDataGridFormatSectionLocale(
2
  section: ParsedDataGridFormatCodeSection,
3
): string | undefined;

`applyDataGridCellFormatPatch`

Merge one public format patch into an effective format.

1
export function applyDataGridCellFormatPatch(
2
  current: DataGridCellFormat | undefined,
3
  patch: DataGridCellFormatPatch,
4
): DataGridCellFormat;

`formatWithValuePresentation`

Select a value presentation while retaining only the appearance layer.

1
export function formatWithValuePresentation(
2
  current: DataGridCellFormat | undefined,
3
  value: DataGridCellFormat['value'],
4
): DataGridCellFormat;

`markDataGridFormatRenderer`

Mark a cell renderer as the authored baseline for an advanced format.

The marker is declarative metadata only. It never talks to a grid or plugin while the renderer runs, so renderers remain pure and safe to reuse.

1
export function markDataGridFormatRenderer<T extends CellTemplate>(
2
  renderer: T,
3
  presentation: string | DataGridCellPresentation,
4
): T;

`getDataGridFormatRendererPresentation`

Return the advanced-format presentation declared by a renderer, if any.

1
export function getDataGridFormatRendererPresentation(
2
  renderer: CellTemplate | undefined,
3
): DataGridCellPresentation | undefined;

`DATA_GRID_FORMAT_RENDERER`

Public metadata key used by renderers that represent a Format Cells presentation.

1
DATA_GRID_FORMAT_RENDERER: typeof DATA_GRID_FORMAT_RENDERER;

`isDataGridFormattingRuntimeState`

1
export function isDataGridFormattingRuntimeState(
2
  value: unknown,
3
): value is DataGridFormattingRuntimeState;

`cloneDataGridFormattingRuntimeState`

1
export function cloneDataGridFormattingRuntimeState(
2
  state: DataGridFormattingRuntimeState,
3
): DataGridFormattingRuntimeState;

`DataGridValueFormatPreset`

Public value-format categories supported by the formatting plugin.

1
/** Public value-format categories supported by the formatting plugin. */
2
export type DataGridValueFormatPreset =
3
  | 'automatic'
4
  | 'number'
5
  | 'currency'
6
  | 'accounting'
7
  | 'percent'
8
  | 'scientific'
9
  | 'date'
10
  | 'datetime'
11
  | 'time'
12
  | 'text';

`DataGridFormattingValueKind`

1
export type DataGridFormattingValueKind =
2
  | 'number'
3
  | 'date'
4
  | 'text'
5
  | 'boolean'
6
  | 'mixed'
7
  | 'unknown';

`DataGridPresetValueFormat`

1
interface DataGridPresetValueFormat {
2
  readonly kind: 'preset';
3
  readonly preset: DataGridValueFormatPreset;
4
  readonly locale?: string;
5
  readonly decimalPlaces?: number;
6
  readonly useGrouping?: boolean;
7
  readonly currency?: string;
8
  readonly dateStyle?: 'short' | 'medium' | 'long' | 'full';
9
  readonly timeStyle?: 'short' | 'medium' | 'long';
10
  readonly timeZone?: string;
11
  readonly negativeStyle?: 'minus' | 'red' | 'parentheses'
12
}

`DataGridCodeValueFormat`

Exact spreadsheet number-format code used by Excel-compatible transports.

1
interface DataGridCodeValueFormat {
2
  readonly kind: 'code';
3
  readonly formatCode: string;
4
  /** Locale used when the code does not carry an explicit locale token. */
5
    readonly locale?: string
6
}

`DataGridValueFormat`

One canonical value-format representation. Presets and exact codes cannot conflict.

1
/** One canonical value-format representation. Presets and exact codes cannot conflict. */
2
export type DataGridValueFormat = DataGridPresetValueFormat | DataGridCodeValueFormat;

`DataGridCellBorder`

1
interface DataGridCellBorder {
2
  readonly style: 'none' | 'solid' | 'dashed' | 'dotted' | 'double';
3
  readonly color?: string;
4
  readonly width?: number
5
}

`DataGridCellAppearance`

1
interface DataGridCellAppearance {
2
  readonly fontFamily?: string;
3
  readonly fontSize?: number;
4
  readonly bold?: boolean;
5
  readonly italic?: boolean;
6
  readonly underline?: boolean;
7
  readonly strike?: boolean;
8
  readonly textColor?: string;
9
  readonly fillColor?: string;
10
  readonly horizontal?: 'automatic' | 'left' | 'center' | 'right' | 'justify';
11
  readonly vertical?: 'top' | 'middle' | 'bottom';
12
  readonly wrap?: boolean;
13
  readonly borderStyle?: 'none' | 'solid' | 'dashed' | 'dotted' | 'double';
14
  readonly borderColor?: string;
15
  /** Per-edge borders take precedence over the legacy uniform border fields. */
16
    readonly borders?: Readonly<Partial<Record<'top' | 'right' | 'bottom' | 'left', DataGridCellBorder>>>;
17
  readonly indent?: number;
18
  readonly textRotation?: number;
19
  readonly shrinkToFit?: boolean
20
}

`DataGridCellPresentation`

A registry-backed cell visualization selected by Format Cells.

1
interface DataGridCellPresentation {
2
  /** Stable built-in or application-defined format id. */
3
    readonly id: string;
4
  /** Serializable values consumed by the format definition. */
5
    readonly options?: Readonly<Record<string, unknown>>
6
}

`DataGridCellFormat`

1
interface DataGridCellFormat {
2
  /** Controls how the raw value is rendered without changing source data. */
3
    readonly value?: DataGridValueFormat;
4
  /** Controls typography, colors, alignment, wrapping, and borders. */
5
    readonly appearance?: DataGridCellAppearance;
6
  /** Optional advanced visualization such as a progress bar or sparkline. */
7
    readonly presentation?: DataGridCellPresentation
8
}

`DataGridCellFormatPatch`

A non-destructive update to one effective cell format.

1
interface DataGridCellFormatPatch {
2
  /** Replaces the value layer. `null` removes it. */
3
    readonly value?: DataGridValueFormat | null;
4
  /** Merges only the supplied appearance properties. `null` removes the layer. */
5
    readonly appearance?: Partial<DataGridCellAppearance> | null;
6
  /** Replaces the advanced presentation. `null` removes it. */
7
    readonly presentation?: DataGridCellPresentation | null
8
}

`DataGridFormattingPatchTarget`

Per-target context supplied to a runtime format patch resolver.

1
interface DataGridFormattingPatchTarget {
2
  readonly current?: DataGridCellFormat;
3
  readonly model?: T;
4
  readonly column: ColumnRegular;
5
  readonly rowType?: DimensionRows
6
}

`DataGridFormattingPatchResolver`

1
export type DataGridFormattingPatchResolver<T extends DataType = DataType> = (
2
  target: DataGridFormattingPatchTarget<T>,
3
) => DataGridCellFormatPatch;

`DataGridAdvancedFormatValueKind`

1
export type DataGridAdvancedFormatValueKind =
2
  | 'number'
3
  | 'boolean'
4
  | 'text'
5
  | 'scalar'
6
  | 'numberArray'
7
  | 'pieArray'
8
  | 'timelineArray'
9
  | 'summaryRecord';

`DataGridAdvancedFormatCompatibilityContext`

1
interface DataGridAdvancedFormatCompatibilityContext {
2
  readonly value: unknown;
3
  readonly model?: DataType;
4
  readonly column?: ColumnRegular;
5
  readonly rowType?: DimensionRows
6
}

`DataGridAdvancedFormatControl`

1
export type DataGridAdvancedFormatControl =
2
  | {
3
      readonly type: 'number';
4
      readonly key: string;
5
      readonly label: string;
6
      readonly min?: number;
7
      readonly max?: number;
8
      readonly step?: number;
9
    }
10
  | {
11
      readonly type: 'boolean';
12
      readonly key: string;
13
      readonly label: string;
14
    }
15
  | {
16
      readonly type: 'select';
17
      readonly key: string;
18
      readonly label: string;
19
      readonly options: readonly { readonly value: string; readonly label: string }[];
20
    }
21
  | {
22
      readonly type: 'color';
23
      readonly key: string;
24
      readonly label: string;
25
    };

`DataGridAdvancedFormatAppearanceSections`

1
interface DataGridAdvancedFormatAppearanceSections {
2
  /** Whether generic text/fill color controls apply to this renderer. */
3
    readonly colors?: boolean;
4
  /**
5
     * Routes generic appearance colors into renderer-owned CSS custom properties
6
     * instead of painting the complete cell.
7
     */
8
    readonly colorVariables?: {
9
      readonly text?: `--${string}`;
10
      readonly fill?: `--${string}`;
11
    }
12
}

`DataGridAdvancedFormatEditorContext`

Runtime context available to advanced-format structured editor factories.

1
interface DataGridAdvancedFormatEditorContext {
2
  readonly schema: ColumnDataSchemaModel;
3
  readonly format?: DataGridCellFormat;
4
  readonly presentation: DataGridAdvancedFormatDefinition;
5
  readonly localeText: DataGridFormattingLocaleText;
6
  readonly revogrid: HTMLRevoGridElement;
7
  readonly providers: PluginProviders;
8
  readonly save: (value?: unknown, preventFocus?: boolean) => void;
9
  readonly close: (focusNext?: boolean) => void
10
}

`DataGridAdvancedFormatEditorFactory`

1
export type DataGridAdvancedFormatEditorFactory = (
2
  context: DataGridAdvancedFormatEditorContext,
3
) => EditorBase;

`DataGridAdvancedFormatExportContext`

Context passed to an advanced presentation’s workbook export formatter.

1
interface DataGridAdvancedFormatExportContext {
2
  /** Raw source value rendered by the presentation. */
3
    readonly value: unknown;
4
  /** Source row that owns the exported cell. */
5
    readonly model: DataType;
6
  /** Column that owns the exported cell. */
7
    readonly column: ColumnRegular;
8
  /** Body or pinned-row segment containing the source row. */
9
    readonly rowType: DimensionRows;
10
  /** Complete effective cell format. */
11
    readonly format: DataGridCellFormat;
12
  /** Definition defaults merged with the selected presentation options. */
13
    readonly options: Readonly<Record<string, unknown>>
14
}

`DataGridAdvancedFormatExportValue`

1
export type DataGridAdvancedFormatExportValue =
2
  | string
3
  | number
4
  | boolean
5
  | Date
6
  | null
7
  | undefined;

`DataGridAdvancedFormatExportFormatter`

Produces a workbook-safe scalar value for an advanced presentation.

1
/** Produces a workbook-safe scalar value for an advanced presentation. */
2
export type DataGridAdvancedFormatExportFormatter = (
3
  context: DataGridAdvancedFormatExportContext,
4
) => DataGridAdvancedFormatExportValue;

`DataGridAdvancedFormatDefinition`

Public registry entry for a built-in override or custom advanced format.

1
interface DataGridAdvancedFormatDefinition {
2
  readonly id: string;
3
  readonly label: string;
4
  readonly description?: string;
5
  readonly group?: string;
6
  readonly order?: number;
7
  readonly icon?: string;
8
  /**
9
     * Renderer applied by this presentation. Use `markDataGridFormatRenderer`
10
     * when the same renderer is also authored directly on columns and should be
11
     * recognized as their Format Cells baseline.
12
     */
13
    readonly cellTemplate: CellTemplate;
14
  /** Optional provider-free renderer used by the detached Format Cells preview. */
15
    readonly previewTemplate?: CellTemplate;
16
  /** Keeps intrinsic preview content from stretching to the preview cell height. */
17
    readonly previewLayout?: 'fill' | 'intrinsic';
18
  /** Shorthand compatibility used by the built-in catalog. */
19
    readonly valueKind?: DataGridAdvancedFormatValueKind;
20
  /** Custom compatibility predicate. It must be true for every selected value. */
21
    readonly isCompatible?: (
22
      context: DataGridAdvancedFormatCompatibilityContext,
23
    ) => boolean;
24
  readonly defaults?: Readonly<Record<string, unknown>>;
25
  readonly controls?: readonly DataGridAdvancedFormatControl[];
26
  /** Generic appearance sections supported by this presentation. */
27
    readonly appearanceSections?: DataGridAdvancedFormatAppearanceSections;
28
  /** Optional editor used only when this presentation is effective for a cell. */
29
    readonly editor?: EditorCtr | string;
30
  /** Context-aware editor factory. Preferred over `editor` when supplied. */
31
    readonly editorFactory?: DataGridAdvancedFormatEditorFactory;
32
  /**
33
     * Converts structured presentation data to a workbook-safe scalar value.
34
     * Source data is not modified.
35
     */
36
    readonly exportValue?: DataGridAdvancedFormatExportFormatter;
37
  /** Native Excel number format applied when this presentation is effective. */
38
    readonly excelNumberFormat?: string;
39
  /** Allows this definition to replace an authored cell template. */
40
    readonly replaceAuthoredTemplate?: boolean;
41
  /** Allows this definition to replace an authored editor. */
42
    readonly replaceAuthoredEditor?: boolean
43
}

`DataGridAdvancedFormatOverride`

1
interface DataGridAdvancedFormatOverride {
2
  readonly label?: string;
3
  readonly description?: string;
4
  readonly defaults?: Readonly<Record<string, unknown>>;
5
  readonly controls?: readonly DataGridAdvancedFormatControl[];
6
  readonly appearanceSections?: DataGridAdvancedFormatAppearanceSections;
7
  readonly previewTemplate?: CellTemplate;
8
  readonly editor?: EditorCtr | string;
9
  readonly editorFactory?: DataGridAdvancedFormatEditorFactory;
10
  readonly exportValue?: DataGridAdvancedFormatExportFormatter;
11
  readonly excelNumberFormat?: string;
12
  readonly replaceAuthoredTemplate?: boolean;
13
  readonly replaceAuthoredEditor?: boolean
14
}

`DataGridFormatContext`

1
interface DataGridFormatContext {
2
  readonly model: T;
3
  readonly value: unknown;
4
  readonly prop: P;
5
  readonly rowType?: DimensionRows
6
}

`DataGridFormatDefinition`

1
export type DataGridFormatDefinition<
2
  T extends DataType = DataType,
3
  P extends ColumnProp = ColumnProp,
4
> =
5
  | DataGridCellFormat
6
  | ((context: DataGridFormatContext<T, P>) => DataGridCellFormat | undefined);

`CellCoordinate`

A zero-based cell coordinate in physical row and column source stores.

1
interface CellCoordinate {
2
  /** Physical index in the selected row type's `source` array. */
3
    readonly row: number;
4
  /** Physical index in the selected column type's `source` array. */
5
    readonly column: number
6
}

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

A physical cell coordinate qualified by its row and column source stores.

1
interface PhysicalCellAddress {
2
  /** Row source containing the cell. Defaults to `rgRow`. */
3
    readonly rowType?: DimensionRows;
4
  /** Column source containing the cell. Defaults to `rgCol`. */
5
    readonly colType?: DimensionCols
6
}

`PhysicalColumnAddress`

A physical column coordinate qualified by its source store.

1
interface PhysicalColumnAddress {
2
  readonly column: number;
3
  /** Column source containing the column. Defaults to `rgCol`. */
4
    readonly colType?: DimensionCols
5
}

`PhysicalRowAddress`

A physical row coordinate qualified by its source store.

1
interface PhysicalRowAddress {
2
  readonly row: number;
3
  /** Row source containing the row. Defaults to `rgRow`. */
4
    readonly rowType?: DimensionRows
5
}

`PhysicalColumnRange`

An inclusive range of complete columns in one physical column source.

1
interface PhysicalColumnRange {
2
  /** First physical column index. */
3
    readonly start: number;
4
  /** Inclusive last physical column index. Defaults to `start`. */
5
    readonly end?: number;
6
  /** Column source containing the target. Defaults to `rgCol`. */
7
    readonly colType?: DimensionCols
8
}

`PhysicalRowRange`

An inclusive range of complete rows in one physical row source.

1
interface PhysicalRowRange {
2
  /** First physical row index. */
3
    readonly start: number;
4
  /** Inclusive last physical row index. Defaults to `start`. */
5
    readonly end?: number;
6
  /** Row source containing the target. Defaults to `rgRow`. */
7
    readonly rowType?: DimensionRows
8
}

`PhysicalCellRange`

A rectangular target expressed by inclusive physical source coordinates.

1
interface PhysicalCellRange {
2
  /** First physical source coordinate. */
3
    readonly start: CellCoordinate;
4
  /** Inclusive opposite corner. Defaults to `start`; reversed corners are normalized. */
5
    readonly end?: CellCoordinate;
6
  /** Row source containing the target. Defaults to `rgRow`. */
7
    readonly rowType?: DimensionRows;
8
  /** Column source containing the target. Defaults to `rgCol`. */
9
    readonly colType?: DimensionCols
10
}

`DataGridFormattingSelection`

One physical range, or several independent/overlapping physical ranges.

1
/** One physical range, or several independent/overlapping physical ranges. */
2
export type DataGridFormattingSelection =
3
  | PhysicalCellRange
4
  | readonly PhysicalCellRange[];

`DataGridFormattingColumnSelection`

Complete-column formatting target, including rows added in the future.

1
interface DataGridFormattingColumnSelection {
2
  readonly scope: 'columns';
3
  readonly ranges: PhysicalColumnRange | readonly PhysicalColumnRange[]
4
}

`DataGridFormattingRowSelection`

Complete-row formatting target, including columns added in the future.

1
interface DataGridFormattingRowSelection {
2
  readonly scope: 'rows';
3
  readonly ranges: PhysicalRowRange | readonly PhysicalRowRange[]
4
}

`DataGridFormattingTarget`

Coordinate-only target accepted by formatting mutation and dialog APIs.

1
/** Coordinate-only target accepted by formatting mutation and dialog APIs. */
2
export type DataGridFormattingTarget =
3
  | DataGridFormattingSelection
4
  | DataGridFormattingColumnSelection
5
  | DataGridFormattingRowSelection;

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

1
interface DataGridFormattingColumnPreset {
2
  /** Format applied to cells in the column. */
3
    readonly format: DataGridCellFormat
4
}

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

1
interface DataGridFormattingRowPreset {
2
  /** Format applied to cells in the row. */
3
    readonly format: DataGridCellFormat
4
}

`DataGridFormattingCellPreset`

1
interface DataGridFormattingCellPreset {
2
  /** Physical range receiving the declarative format. */
3
    readonly range: PhysicalCellRange;
4
  readonly format: DataGridCellFormat
5
}

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

One persisted runtime formatting operation for a complete column.

1
interface DataGridFormattingRuntimeColumnState {
2
  /** `null` preserves an explicit Clear formatting operation. */
3
    readonly format: DataGridCellFormat | null;
4
  /** Monotonic operation order used for cell/row/column precedence. */
5
    readonly revision: number
6
}

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

One persisted runtime formatting operation for a complete row.

1
interface DataGridFormattingRuntimeRowState {
2
  /** `null` preserves an explicit Clear formatting operation. */
3
    readonly format: DataGridCellFormat | null;
4
  /** Monotonic operation order used for row/column/cell precedence. */
5
    readonly revision: number
6
}

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

One persisted runtime formatting operation for a physical cell.

1
interface DataGridFormattingRuntimeCellState {
2
  readonly rowType?: DimensionRows;
3
  readonly colType?: DimensionCols;
4
  /** `null` preserves an explicit Clear formatting operation. */
5
    readonly format: DataGridCellFormat | null;
6
  /** Monotonic operation order used for cell/row/column precedence. */
7
    readonly revision: number
8
}

`DataGridFormattingRuntimeState`

Versioned coordinate state for formats created through the dialog or plugin API.

1
interface DataGridFormattingRuntimeState {
2
  readonly version: 3;
3
  readonly revision: number;
4
  readonly columns: readonly DataGridFormattingRuntimeColumnState[];
5
  readonly rows: readonly DataGridFormattingRuntimeRowState[];
6
  readonly cells: readonly DataGridFormattingRuntimeCellState[]
7
}

`DataGridFormattingChangeSource`

Why a runtime formatting state changed.

1
/** Why a runtime formatting state changed. */
2
export type DataGridFormattingChangeSource =
3
  | 'apply'
4
  | 'clear'
5
  | 'set-state'
6
  | 'history'
7
  | 'autofill'
8
  | 'structure';

`DataGridFormattingChangeEvent`

Complete application-facing payload emitted after a runtime formatting change.

1
interface DataGridFormattingChangeEvent {
2
  /** Complete state to persist. */
3
    readonly state: DataGridFormattingRuntimeState;
4
  /** Complete state before this operation, used by HistoryPlugin. */
5
    readonly previousState: DataGridFormattingRuntimeState;
6
  /** Operation that produced the state. */
7
    readonly source: DataGridFormattingChangeSource
8
}

`DataGridFormattingHistoryRuntime`

Runtime contract used by HistoryPlugin to replay formatting entries.

1
interface DataGridFormattingHistoryRuntime {
2
  applyHistoryState(state: DataGridFormattingRuntimeState): boolean;
3
  /** @internal Prevent coordinate remapping while a structural snapshot is replayed. */
4
    beginHistoryStructureReplay?(): void;
5
  /** @internal Resume ordinary structural coordinate reconciliation. */
6
    endHistoryStructureReplay?(): void;
7
  /** @internal Flush a partially applied structural context-menu transaction. */
8
    flushPendingStructuralTransaction?(transactionId: number): void
9
}

`DataGridFormattingPresetState`

Declarative formats and optional runtime state assigned through grid.dataGridFormatting. Reassign the property to replace presets reactively. Applications own persistence and can restore a state received from datagridformattingchange through the state property.

Cell presets are physical ranges, so replacing source objects does not require row identity configuration.

1
interface DataGridFormattingPresetState {
2
  readonly columns?: readonly DataGridFormattingColumnPreset[];
3
  readonly rows?: readonly DataGridFormattingRowPreset[];
4
  readonly cells?: readonly DataGridFormattingCellPreset[];
5
  /** Runtime Apply and Clear operations previously emitted by the plugin. */
6
    readonly state?: DataGridFormattingRuntimeState
7
}

`DataGridFormattingResolvedSelection`

@internal Model-backed target resolved from coordinates or UI selection.

1
interface DataGridFormattingResolvedSelection {
2
  /** Whether the operation targets explicit cells, complete rows, or complete columns. */
3
    readonly scope: 'cells' | 'rows' | 'columns';
4
  /** Columns included in the operation. */
5
    readonly columns: readonly ColumnRegular[];
6
  /** Exact cell targets. Required when `scope` is `cells`. */
7
    readonly cells: readonly DataGridFormattingCell<T>[];
8
  /** Useful for type resolution and dialog preview in column scope. */
9
    readonly rows: readonly T[];
10
  /** Physical row addresses retained for complete-row storage operations. */
11
    readonly rowAddresses?: readonly Required<PhysicalRowAddress>[]
12
}

`DataGridFormattingCell`

1
interface DataGridFormattingCell {
2
  /** Source row containing the cell. */
3
    readonly model: T;
4
  /** Column containing the cell. */
5
    readonly column: ColumnRegular;
6
  /** Body or pinned-row dimension containing the cell. */
7
    readonly rowType?: DimensionRows;
8
  /** Physical address resolved for coordinate-owned formatting storage. */
9
    readonly address?: PhysicalCellAddress
10
}

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

1
interface DataGridFormattingConfig {
2
  /** Overrides automatic value-kind inference for the complete selection. */
3
    readonly resolveValueKind?: (
4
      selection: DataGridFormattingResolvedSelection<T>,
5
    ) => DataGridFormattingValueKind;
6
  /** Maps application column-type names to formatting value kinds. */
7
    readonly columnTypeKinds?: Readonly<Record<string, DataGridFormattingValueKind>>;
8
  /** Context-menu surfaces allowed to create formatting selections. */
9
    readonly scopes?: readonly ('cell' | 'columnHeader')[];
10
  /**
11
     * Stable application identity used to retain formatting when a
12
     * length-changing source update replaces row objects immutably.
13
     */
14
    readonly resolveStructuralRowIdentity?: (
15
      model: T,
16
      context: { readonly row: number; readonly rowType: DimensionRows },
17
    ) => unknown;
18
  /** Advanced visual formats and format-resolved editors. `false` disables them. */
19
    readonly advancedFormats?: false | DataGridAdvancedFormatsConfig
20
}

`DataGridFormattingLocaleText`

1
interface DataGridFormattingLocaleText {
2
  readonly title: string;
3
  readonly close: string;
4
  readonly description: string;
5
  readonly selectionSummary: string;
6
  readonly selectionCells: string;
7
  readonly selectionColumns: string;
8
  readonly valueSection: string;
9
  readonly advancedSection: string;
10
  readonly advancedNone: string;
11
  readonly advancedDescription: string;
12
  readonly automaticDescription: string;
13
  readonly numberSection: string;
14
  readonly category: string;
15
  readonly locale: string;
16
  readonly browserDefault: string;
17
  readonly decimals: string;
18
  readonly grouping: string;
19
  readonly currency: string;
20
  readonly negativeNumbers: string;
21
  readonly dateStyle: string;
22
  readonly timeStyle: string;
23
  readonly custom: string;
24
  readonly formatCode: string;
25
  readonly invalidFormatCode: string;
26
  readonly fontSection: string;
27
  readonly typographySection: string;
28
  readonly colorsSection: string;
29
  readonly fontFamily: string;
30
  readonly defaultFont: string;
31
  readonly fontSize: string;
32
  readonly bold: string;
33
  readonly italic: string;
34
  readonly underline: string;
35
  readonly strike: string;
36
  readonly textColor: string;
37
  readonly fillColor: string;
38
  readonly useTextColor: string;
39
  readonly useFillColor: string;
40
  readonly defaultColor: string;
41
  readonly noFill: string;
42
  readonly customColor: string;
43
  readonly customColorHex: string;
44
  readonly invalidColor: string;
45
  readonly colorLabels: Readonly<Record<string, string>>;
46
  /** Labels for registry groups, keyed by the definition's `group` value. */
47
    readonly advancedGroupLabels: Readonly<Record<string, string>>;
48
  /** Advanced-format names keyed by stable format id. */
49
    readonly advancedFormatLabels: Readonly<Record<string, string>>;
50
  /** Advanced-format descriptions keyed by stable format id. */
51
    readonly advancedFormatDescriptions: Readonly<Record<string, string>>;
52
  /** Control labels keyed as `<format id>.<control key>`. */
53
    readonly advancedControlLabels: Readonly<Record<string, string>>;
54
  /** Select-option labels keyed as `<format id>.<control key>.<option value>`. */
55
    readonly advancedOptionLabels: Readonly<Record<string, string>>;
56
  readonly expandSection: string;
57
  readonly collapseSection: string;
58
  readonly alignmentSection: string;
59
  readonly horizontal: string;
60
  readonly vertical: string;
61
  readonly wrap: string;
62
  readonly borderSection: string;
63
  readonly borderStyle: string;
64
  readonly borderColor: string;
65
  readonly preview: string;
66
  readonly previewOriginal: string;
67
  readonly previewFormatted: string;
68
  readonly previewHint: string;
69
  readonly clear: string;
70
  readonly cancel: string;
71
  readonly apply: string;
72
  readonly textExample: string;
73
  readonly presetLabels: Record<DataGridValueFormatPreset, string>;
74
  readonly optionLabels: DataGridFormattingOptionLocaleText;
75
  readonly dataEditor: DataGridFormattingDataEditorLocaleText
76
}

`DataGridFormattingDataEditorLocaleText`

1
export type DataGridFormattingDataEditorLocaleText = StructuredDataEditorLocaleText;

`DataGridFormattingOptionLocaleText`

1
interface DataGridFormattingOptionLocaleText {
2
  readonly automatic: string;
3
  readonly left: string;
4
  readonly center: string;
5
  readonly right: string;
6
  readonly top: string;
7
  readonly middle: string;
8
  readonly bottom: string;
9
  readonly none: string;
10
  readonly solid: string;
11
  readonly dashed: string;
12
  readonly dotted: string;
13
  readonly double: string;
14
  readonly short: string;
15
  readonly medium: string;
16
  readonly long: string;
17
  readonly full: string;
18
  readonly negativeMinus: string;
19
  readonly negativeRed: string;
20
  readonly negativeParentheses: string
21
}

`DataGridFormattingDialogConfig`

1
interface DataGridFormattingDialogConfig {
2
  /** Right-align numeric values and numeric presets when horizontal alignment is automatic. Defaults to true. */
3
    readonly autoAlignNumericValues?: boolean;
4
  readonly locale?: string;
5
  /** Locale choices shown in the Format Cells dialog. Common US and European locales are used by default. */
6
    readonly locales?: readonly string[];
7
  readonly currencies?: readonly string[];
8
  readonly fontFamilies?: readonly string[];
9
  readonly localeText?: Partial<Omit<
10
      DataGridFormattingLocaleText,
11
      | 'presetLabels'
12
      | 'optionLabels'
13
      | 'colorLabels'
14
      | 'advancedGroupLabels'
15
      | 'advancedFormatLabels'
16
      | 'advancedFormatDescriptions'
17
      | 'advancedControlLabels'
18
      | 'advancedOptionLabels'
19
      | 'dataEditor'
20
    >> & {
21
      readonly presetLabels?: Partial<DataGridFormattingLocaleText['presetLabels']>;
22
      readonly optionLabels?: Partial<DataGridFormattingOptionLocaleText>;
23
      readonly colorLabels?: Readonly<Record<string, string>>;
24
      readonly advancedGroupLabels?: Readonly<Record<string, string>>;
25
      readonly advancedFormatLabels?: Readonly<Record<string, string>>;
26
      readonly advancedFormatDescriptions?: Readonly<Record<string, string>>;
27
      readonly advancedControlLabels?: Readonly<Record<string, string>>;
28
      readonly advancedOptionLabels?: Readonly<Record<string, string>>;
29
      readonly dataEditor?: Partial<DataGridFormattingDataEditorLocaleText>;
30
    }
31
}

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

1
interface DataGridFormattingDialogOpenOptions {
2
  readonly selection: DataGridFormattingResolvedSelection<T>;
3
  readonly initialValue?: DataGridCellFormat;
4
  readonly sampleValue?: unknown;
5
  readonly valueKind: DataGridFormattingValueKind;
6
  /** False when selected columns cannot safely replace their visual value presentation. */
7
    readonly valueFormatting?: boolean;
8
  /** Resolved compatible advanced-format catalog for this selection. */
9
    readonly advancedFormatDefinitions?: readonly DataGridAdvancedFormatDefinition[];
10
  readonly onApply: (format: DataGridCellFormat) => void;
11
  readonly onClear: () => void
12
}

`createAutofillFormattingEntries`

1
export function createAutofillFormattingEntries({
2
  providers,
3
  owner,
4
  oldRange,
5
  newRange,
6
  rowType,
7
  colType,
8
}: {
9
  providers: PluginProviders;
10
  owner: Pick<AutofillFormattingOwner, 'getFormat'>;
11
  oldRange: RangeArea;
12
  newRange: RangeArea;
13
  rowType: DimensionRows;
14
  colType: DimensionCols;
15
}): AutofillFormattingBatchEntry[];

`AutofillFormattingBatchEntry`

1
interface AutofillFormattingBatchEntry {
2
  readonly target: DataGridFormattingTarget;
3
  readonly format: DataGridCellFormat | undefined
4
}

`AutofillFormattingController`

Couples accepted range edits to formatting without moving value generation out of Core or AutoFillPlugin.

1
class AutofillFormattingController {
2
  destroy(): void;
3
}

`applyDataGridFormattingRender`

Compose formatting into one core before-cell-render schema.

1
export function applyDataGridFormattingRender<T extends DataType>(
2
  event: CustomEvent<HTMLRevogrDataElementEventMap['beforecellrender']>,
3
  context: DataGridFormattingRenderContext<T>,
4
): void;

`DataGridFormattingRenderContext`

1
interface DataGridFormattingRenderContext {
2
  readonly providers: PluginProviders;
3
  readonly config: Readonly<DataGridFormattingConfig<T>>;
4
  readonly advancedFormatDefinitions: readonly DataGridAdvancedFormatDefinition[];
5
  readonly resolveCellValue: (
6
      model: T,
7
      column: ColumnRegular,
8
      rowType?: DimensionRows,
9
      value?: unknown,
10
    ) => unknown;
11
  readonly resolveFormat: (
12
      address: PhysicalCellAddress,
13
      column?: ColumnRegular,
14
      model?: T,
15
      value?: unknown,
16
      includeRenderer?: boolean,
17
    ) => DataGridCellFormat | undefined;
18
  readonly resolveAuthoredFormat: (
19
      column: ColumnRegular,
20
      model?: T,
21
      value?: unknown,
22
      rowType?: DimensionRows,
23
      includeRenderer?: boolean,
24
    ) => DataGridCellFormat | undefined
25
}

`StoredDataGridFormat`

1
interface StoredDataGridFormat {
2
  readonly revision: number;
3
  readonly value?: DataGridCellFormat
4
}

`DataGridFormattingStructuralRemapResult`

1
interface DataGridFormattingStructuralRemapResult {
2
  readonly runtimeChanged: boolean;
3
  readonly presetsChanged: boolean
4
}

`resolveDataGridFormattingSelection`

Resolve public physical coordinates into the plugin’s model-backed target.

1
export function resolveDataGridFormattingSelection<T extends DataType>(
2
  target: DataGridFormattingTarget,
3
  providers: PluginProviders,
4
): DataGridFormattingResolvedSelection<T> | undefined;

`expandPhysicalColumnSelection`

Expand and deduplicate complete-column coordinate ranges.

1
export function expandPhysicalColumnSelection(
2
  target: Extract<DataGridFormattingTarget, { scope: 'columns' }>,
3
): Required<PhysicalColumnAddress>[];

`expandPhysicalRowSelection`

Expand and deduplicate complete-row coordinate ranges.

1
export function expandPhysicalRowSelection(
2
  target: Extract<DataGridFormattingTarget, { scope: 'rows' }>,
3
): Required<PhysicalRowAddress>[];

`resolvedFormattingSelectionToTarget`

Convert an internal model-backed UI selection to the public coordinate target.

1
export function resolvedFormattingSelectionToTarget<T extends DataType>(
2
  selection: DataGridFormattingResolvedSelection<T>,
3
  providers: PluginProviders,
4
): DataGridFormattingTarget | undefined;

`expandPhysicalFormattingSelection`

Expand and deduplicate physical ranges without consulting current grid data.

1
export function expandPhysicalFormattingSelection(
2
  target: DataGridFormattingSelection,
3
): Required<PhysicalCellAddress>[];

`resolvePhysicalFormattingCell`

Resolve a physical address to its current model and column context.

1
export function resolvePhysicalFormattingCell<T extends DataType>(
2
  providers: PluginProviders,
3
  address: PhysicalCellAddress,
4
): DataGridFormattingCell<T> | undefined;

`resolvePhysicalFormattingAddress`

Resolve transient render/editor models to their current physical source address.

1
export function resolvePhysicalFormattingAddress<T extends DataType>(
2
  providers: PluginProviders,
3
  model: T,
4
  column: ColumnRegular,
5
  rowType: DimensionRows = 'rgRow',
6
  colType?: DimensionCols,
7
): PhysicalCellAddress | undefined;

`resolvePhysicalFormattingColumn`

Resolve a column object to its physical source address.

1
export function resolvePhysicalFormattingColumn(
2
  providers: PluginProviders,
3
  column: ColumnRegular,
4
  preferredType?: DimensionCols,
5
): PhysicalColumnAddress | undefined;

`resolvePhysicalFormattingRow`

Resolve a row object to its physical source address.

1
export function resolvePhysicalFormattingRow<T extends DataType>(
2
  providers: PluginProviders,
3
  model: T,
4
  preferredType?: DimensionRows,
5
): PhysicalRowAddress | undefined;

`visibleCellToPhysicalFormattingAddress`

Translate a rendered virtual cell into a physical address.

1
export function visibleCellToPhysicalFormattingAddress(
2
  providers: PluginProviders,
3
  {
4
    row,
5
    column,
6
    rowType = 'rgRow',
7
    colType = 'rgCol',
8
  }: PhysicalCellAddress,
9
): PhysicalCellAddress | undefined;

`visibleRangeToPhysicalFormattingSelection`

Convert one visible range into physical formatting coordinates.

1
export function visibleRangeToPhysicalFormattingSelection(
2
  providers: PluginProviders,
3
  range: {
4
    readonly x: number;
5
    readonly y: number;
6
    readonly x1: number;
7
    readonly y1: number;
8
    readonly rowType?: DimensionRows;
9
    readonly colType?: DimensionCols;
10
  },
11
): DataGridFormattingSelection;

`AdvancedFormatPanel`

1
export function AdvancedFormatPanel({
2
  definitions,
3
  presentation,
4
  locale,
5
  localeText,
6
  onChange,
7
}: {
8
  readonly definitions: readonly DataGridAdvancedFormatDefinition[];
9
  readonly presentation?: DataGridCellPresentation;
10
  readonly locale: DataGridFormattingLocaleText;
11
  readonly localeText?: DataGridFormattingDialogConfig['localeText'];
12
  readonly onChange: (value: DataGridCellPresentation | undefined) => void;
13
});

`AlignmentSection`

1
export function AlignmentSection({ appearance, locale, onChange }: SectionProps);

`AppearancePanel`

1
export function AppearancePanel({ appearance, sections, options, locale, onChange }: {
2
  readonly appearance: DataGridCellAppearance;
3
  readonly sections?: DataGridAdvancedFormatAppearanceSections;
4
  readonly options: DataGridFormattingDialogOpenOptions;
5
  readonly locale: DataGridFormattingLocaleText;
6
  readonly onChange: (value: DataGridCellAppearance) => void;
7
});

`BordersSection`

1
export function BordersSection({ appearance, locale, onChange }: SectionProps);

`FormattingColorPicker`

1
export function FormattingColorPicker({
2
  label,
3
  value,
4
  defaultLabel,
5
  customLabel,
6
  customHexLabel,
7
  invalidColor,
8
  colorLabels,
9
  optional = true,
10
  onChange,
11
}: {
12
  readonly label: string;
13
  readonly value?: string;
14
  readonly defaultLabel: string;
15
  readonly customLabel: string;
16
  readonly customHexLabel: string;
17
  readonly invalidColor: string;
18
  readonly colorLabels: Readonly<Record<string, string>>;
19
  readonly optional?: boolean;
20
  readonly onChange: (value: string | undefined) => void;
21
});

`normalizeHexColor`

1
export function normalizeHexColor(value: string | undefined): string | undefined;

`ColorsSection`

1
export function ColorsSection({ appearance, locale, onChange }: SectionProps);

`useControlTooltip`

1
export function useControlTooltip(text: string);

`ControlTooltip`

1
export function ControlTooltip({ id, text, visible }: {
2
  readonly id: string;
3
  readonly text: string;
4
  readonly visible: boolean;
5
});

`FormatPreview`

1
export function FormatPreview({
2
  sampleValue,
3
  format,
4
  locale,
5
  advancedFormatDefinitions,
6
  autoAlignNumericValues,
7
}: {
8
  readonly sampleValue: unknown;
9
  readonly format: DataGridCellFormat;
10
  readonly locale: DataGridFormattingLocaleText;
11
  readonly advancedFormatDefinitions?: readonly DataGridAdvancedFormatDefinition[];
12
  readonly autoAlignNumericValues: boolean;
13
});

`FormatIcon`

1
export function FormatIcon({ icon, className = 'rv-format-icon' }: {
2
  readonly icon: string;
3
  readonly className?: string;
4
});

`FORMAT_ICONS`

1
FORMAT_ICONS: { readonly accounting: string; readonly alignCenter: string; readonly alignLeft: string; readonly alignRight: string; readonly arrowLeft: string; readonly arrowRight: string; readonly automatic: string; readonly ban: string; readonly bold: string; readonly border: string; readonly calendar: string; readonly chevronDown: string; readonly clock: string; readonly currency: string; readonly ellipsis: string; readonly eraser: string; readonly fill: string; readonly italic: string; readonly number: string; readonly palette: string; readonly percent: string; readonly scientific: string; readonly sliders: string; readonly strike: string; readonly text: string; readonly underline: string; readonly verticalBottom: string; readonly verticalMiddle: string; readonly verticalTop: string; readonly wrap: string; };

`ADVANCED_FORMAT_ICONS`

1
ADVANCED_FORMAT_ICONS: { readonly progressLine: string; readonly progressWithValue: string; readonly circularProgress: string; readonly heatmap: string; readonly rating: string; readonly change: string; readonly threshold: string; readonly thumbs: string; readonly badge: string; readonly sparkline: string; readonly bar: string; readonly pie: string; readonly timeline: string; readonly avatar: string; readonly avatarWithText: string; readonly summaryPercentage: string; readonly summaryAggregate: string; };

`InspectorSection`

1
export function InspectorSection({
2
  title,
3
  icon,
4
  locale,
5
  open = false,
6
  children,
7
}: {
8
  readonly title: string;
9
  readonly icon: string;
10
  readonly locale: DataGridFormattingLocaleText;
11
  readonly open?: boolean;
12
  readonly children: ComponentChildren;
13
});

`resolveDataGridFormattingLocaleOptions`

1
export function resolveDataGridFormattingLocaleOptions(
2
  configuredLocales?: readonly string[],
3
  selectedLocale?: string,
4
): readonly DataGridFormattingLocaleOption[];

`DataGridFormattingLocaleOption`

1
interface DataGridFormattingLocaleOption {
2
  readonly value: string;
3
  readonly label: string
4
}

`DEFAULT_DATA_GRID_FORMATTING_LOCALES`

1
DEFAULT_DATA_GRID_FORMATTING_LOCALES: readonly string[];

`formatLocaleTemplate`

1
export function formatLocaleTemplate(
2
  template: string,
3
  values: Readonly<Record<string, string>>,
4
): string;

`DataGridFormattingEditorRuntime`

Owns editor proxy installation and effective editor construction.

1
class DataGridFormattingEditorRuntime {
2
  install(collection: ColumnCollection): void;
3

4
  installCurrent(): void;
5
}

`SegmentedControl`

1
export function SegmentedControl<Value extends string>({
2
  value,
3
  options,
4
  ariaLabel,
5
  onChange,
6
}: {
7
  readonly value: Value;
8
  readonly options: readonly SegmentedOption<Value>[];
9
  readonly ariaLabel: string;
10
  readonly onChange: (value: Value) => void;
11
});

`ToggleIconButton`

1
export function ToggleIconButton({
2
  value,
3
  label,
4
  icon,
5
  onChange,
6
}: {
7
  readonly value: boolean;
8
  readonly label: string;
9
  readonly icon: string;
10
  readonly onChange: (value: boolean) => void;
11
});

`SegmentedOption`

1
interface SegmentedOption {
2
  readonly value: Value;
3
  readonly label: string;
4
  readonly icon: string
5
}

`TypographySection`

1
export function TypographySection({ appearance, options, locale, onChange }: SectionProps);

`SectionProps`

1
interface SectionProps {
2
  readonly appearance: DataGridCellAppearance;
3
  readonly options: DataGridFormattingDialogOpenOptions;
4
  readonly locale: DataGridFormattingLocaleText;
5
  readonly onChange: (value: Partial<DataGridCellAppearance>) => void
6
}

`ValueFormatPanel`

1
export function ValueFormatPanel({
2
  value,
3
  presentation,
4
  options,
5
  locale,
6
  onChange,
7
  onValidityChange,
8
  onPresentationChange,
9
}: {
10
  readonly value: DataGridValueFormat;
11
  readonly presentation?: DataGridCellPresentation;
12
  readonly options: DataGridFormattingDialogOpenOptions;
13
  readonly locale: DataGridFormattingLocaleText;
14
  readonly onChange: (value: DataGridValueFormat) => void;
15
  readonly onValidityChange: (valid: boolean) => void;
16
  readonly onPresentationChange: (value: DataGridCellPresentation | undefined) => void;
17
});

`ValueFormatPresets`

1
export function ValueFormatPresets({
2
  value,
3
  formatLocale,
4
  currency,
5
  locale,
6
  advancedAvailable,
7
  onChange,
8
}: {
9
  readonly value: FormatCategory;
10
  readonly formatLocale?: string;
11
  readonly currency?: string;
12
  readonly locale: DataGridFormattingLocaleText;
13
  readonly advancedAvailable: boolean;
14
  readonly onChange: (value: FormatCategory) => void;
15
});

`FormatCategory`

1
export type FormatCategory = DataGridValueFormatPreset | 'custom' | 'advanced';

`resolveDataGridHorizontalAlignment`

Chooses the horizontal alignment that a formatted cell should display.

Explicit left, center, and right appearance values always win. When alignment is omitted or automatic, ordinary numeric values and numeric presets resolve to right. An active advanced presentation keeps control of its own layout unless the user explicitly selected an alignment.

This function only calculates the effective value. It does not modify the cell format, source value, column, or persisted formatting state.

@param options Cell value and formatting context used to resolve alignment.

@returns The alignment to apply, or undefined when the existing cell or presentation layout should remain unchanged.

1
export function resolveDataGridHorizontalAlignment(
2
  options: {
3
    /** Raw cell value before display formatting. */
4
    readonly value: unknown;
5
    /** Effective cell format, including value preset and authored appearance. */
6
    readonly format?: DataGridCellFormat;
7
    /** Whether omitted or Automatic alignment may be derived from numeric data. */
8
    readonly autoAlignNumericValues?: boolean;
9
    /** True when an active advanced renderer owns the cell's visual layout. */
10
    readonly hasEffectivePresentation?: boolean;
11
  },
12
): DataGridHorizontalAlignment | undefined;

`isDataGridNumericValue`

Reports whether a raw cell value participates in automatic numeric alignment.

Finite JavaScript numbers and all bigint values are numeric. NaN, positive or negative infinity, numeric strings, and boxed numbers are intentionally excluded so their existing grid alignment is preserved.

@param value Raw source value to classify.

@returns true when automatic numeric alignment may apply to the value.

1
export function isDataGridNumericValue(value: unknown): boolean;

`structuralAddressKey`

1
export function structuralAddressKey<T extends string>(type: T, index: number): string;

`createRowStructuralMap`

Match retained records by identity, including duplicate references, then preserve coordinates for a same-size immutable source replacement.

1
export function createRowStructuralMap(
2
  previous: Readonly<Record<DimensionRows, readonly DataType[]>>,
3
  next: Readonly<Record<DimensionRows, readonly DataType[]>>,
4
  fallbackIdentity?: (
5
    row: DataType,
6
    address: StructuralAddress<DimensionRows>,
7
  ) => unknown,
8
): StructuralAddressMap<DimensionRows>;

`createColumnStructuralMap`

Match columns by identity and fall back to their stable data property.

1
export function createColumnStructuralMap(
2
  previous: Readonly<Record<DimensionCols, readonly ColumnRegular[]>>,
3
  next: Readonly<Record<DimensionCols, readonly ColumnRegular[]>>,
4
): StructuralAddressMap<DimensionCols>;

`StructuralAddress`

1
interface StructuralAddress {
2
  readonly type: T;
3
  readonly index: number
4
}

`StructuralAddressMap`

1
export type StructuralAddressMap<T extends string> = ReadonlyMap<
2
  string,
3
  StructuralAddress<T>
4
>;

`FORMATTING_ROW_TYPES`

1
FORMATTING_ROW_TYPES: readonly DimensionRows[];

`FORMATTING_COLUMN_TYPES`

1
FORMATTING_COLUMN_TYPES: readonly DimensionCols[];

`normalizeFormattingCellAddress`

1
export function normalizeFormattingCellAddress(
2
  address: PhysicalCellAddress,
3
): Required<PhysicalCellAddress>;

`normalizeFormattingColumnAddress`

1
export function normalizeFormattingColumnAddress(
2
  address: PhysicalColumnAddress,
3
): Required<PhysicalColumnAddress>;

`normalizeFormattingRowAddress`

1
export function normalizeFormattingRowAddress(
2
  address: PhysicalRowAddress,
3
): Required<PhysicalRowAddress>;

`formattingCellAddressKey`

1
export function formattingCellAddressKey(address: PhysicalCellAddress): string;

`formattingColumnAddressKey`

1
export function formattingColumnAddressKey(address: PhysicalColumnAddress): string;

`formattingRowAddressKey`

1
export function formattingRowAddressKey(address: PhysicalRowAddress): string;

`DEFAULT_FORMATTING_ROW_TYPE`

1
DEFAULT_FORMATTING_ROW_TYPE: DimensionRows;

`DEFAULT_FORMATTING_COLUMN_TYPE`

1
DEFAULT_FORMATTING_COLUMN_TYPE: DimensionCols;

`evaluateDataGridFormatCode`

1
export function evaluateDataGridFormatCode(
2
  parsed: ParsedDataGridFormatCode,
3
  value: unknown,
4
  locale?: string,
5
): DataGridFormattedCodeValue;

`classifyDataGridFormatCode`

1
export function classifyDataGridFormatCode(
2
  parsed: ParsedDataGridFormatCode,
3
): DataGridFormattedCodeValue['kind'];

`parseDataGridFormatCode`

1
export function parseDataGridFormatCode(code: string): ParsedDataGridFormatCode;

`importDataGridExcelClipboardDisplayValue`

Convert display-only Excel HTML text into a canonical typed value.

1
export function importDataGridExcelClipboardDisplayValue(
2
  displayText: string,
3
  format?: DataGridCellFormat,
4
): unknown;

`normalizeExcelLanguage`

1
export function normalizeExcelLanguage(value?: string): string | undefined;

`normalizeExcelNamedNumberFormat`

1
export function normalizeExcelNamedNumberFormat(
2
  value: string | undefined,
3
  language?: string,
4
): NormalizedExcelNumberFormat;

`NormalizedExcelNumberFormat`

1
interface NormalizedExcelNumberFormat {
2
  readonly formatCode?: string;
3
  readonly locale?: string
4
}

Data Grid Formatting

Module Extensions

DataGridAdvancedFormatsConfig

HTMLRevoGridElementEventMap (Extended from global)

HTMLRevoGridElement (Extended from global)

ColumnRegular (Extended from @revolist/revogrid)

AdditionalData (Extended from @revolist/revogrid)

Plugin API

DataGridFormattingPluginOptions

DataGridFormattingPlugin

Dependencies

isDataGridFormattingRuntime

DATA_GRID_FORMATTING_PLUGIN

DATA_GRID_FORMATTING_CHANGE_EVENT

DATA_GRID_FORMATTING_CONFIGURATION_CHANGE_EVENT

DataGridFormattingRuntime (Extended from index.ts)

DataGridExcelClipboardValue

resolveDataGridFormattingLocale

DATA_GRID_FORMATTING_LOCALE

DataGridFormatDialogPlugin

Dependencies

createDataGridFormattingEditor

DataGridFormattingEditor

importDataGridExcelClipboardFormat

exportDataGridExcelClipboardFormat

exportDataGridExcelClipboardValue

createDataGridExcelNumberFormat

importDataGridExcelClipboardValue

resolveDataGridAdvancedFormats

compatibleDataGridAdvancedFormats

isDataGridAdvancedFormatCompatible

findDataGridAdvancedFormat

resolveDataGridRendererFormat

dataGridAdvancedAppearanceColorStyle

DATA_GRID_BUILT_IN_ADVANCED_FORMATS

createDataGridValueFormat

createDataGridCodeFormat

isDataGridPresetValueFormat

isDataGridCodeValueFormat

inferDataGridFormattingKind

formatDataGridValue

formatDataGridExcelCode

classifyDataGridValueFormat

formatDataGridAutomaticValue

isDataGridNumberPreset

isDataGridDatePreset

normalizeDataGridLocale

normalizeDataGridCurrency

toDataGridDate

DataGridFormattingValueResolver

compileDataGridFormatCode

validateDataGridFormatCode

formatDataGridCodeValue

classifyDataGridCodeValue

getDataGridFormatCodeCacheSize

MAX_DATA_GRID_FORMAT_CODE_LENGTH

DataGridFormatCodeValueKind

DataGridFormatCodeDiagnostic

DataGridFormatCodeSegment

DataGridFormattedCodeValue

DataGridFormatCodeConditionOperator

DataGridFormatCodeCondition

DataGridFormatCodeToken

ParsedDataGridFormatCodeSection

ParsedDataGridFormatCode

resolveDataGridFormatCodeLocale

resolveDataGridFormatSectionLocale

applyDataGridCellFormatPatch

formatWithValuePresentation

markDataGridFormatRenderer

getDataGridFormatRendererPresentation

DATA_GRID_FORMAT_RENDERER

isDataGridFormattingRuntimeState

cloneDataGridFormattingRuntimeState

DataGridValueFormatPreset

DataGridFormattingValueKind

DataGridPresetValueFormat

DataGridCodeValueFormat

DataGridValueFormat

DataGridCellBorder

`DataGridAdvancedFormatsConfig`

`HTMLRevoGridElementEventMap` (Extended from `global`)

`HTMLRevoGridElement` (Extended from `global`)

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

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

`DataGridFormattingPluginOptions`

`DataGridFormattingPlugin`

`isDataGridFormattingRuntime`

`DATA_GRID_FORMATTING_PLUGIN`

`DATA_GRID_FORMATTING_CHANGE_EVENT`

`DATA_GRID_FORMATTING_CONFIGURATION_CHANGE_EVENT`

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

`DataGridExcelClipboardValue`

`resolveDataGridFormattingLocale`

`DATA_GRID_FORMATTING_LOCALE`

`DataGridFormatDialogPlugin`

`createDataGridFormattingEditor`

`DataGridFormattingEditor`

`importDataGridExcelClipboardFormat`

`exportDataGridExcelClipboardFormat`

`exportDataGridExcelClipboardValue`

`createDataGridExcelNumberFormat`

`importDataGridExcelClipboardValue`

`resolveDataGridAdvancedFormats`

`compatibleDataGridAdvancedFormats`

`isDataGridAdvancedFormatCompatible`

`findDataGridAdvancedFormat`

`resolveDataGridRendererFormat`

`dataGridAdvancedAppearanceColorStyle`

`DATA_GRID_BUILT_IN_ADVANCED_FORMATS`

`createDataGridValueFormat`

`createDataGridCodeFormat`

`isDataGridPresetValueFormat`

`isDataGridCodeValueFormat`

`inferDataGridFormattingKind`

`formatDataGridValue`

`formatDataGridExcelCode`

`classifyDataGridValueFormat`

`formatDataGridAutomaticValue`

`isDataGridNumberPreset`

`isDataGridDatePreset`

`normalizeDataGridLocale`

`normalizeDataGridCurrency`

`toDataGridDate`

`DataGridFormattingValueResolver`

`compileDataGridFormatCode`

`validateDataGridFormatCode`

`formatDataGridCodeValue`

`classifyDataGridCodeValue`

`getDataGridFormatCodeCacheSize`

`MAX_DATA_GRID_FORMAT_CODE_LENGTH`

`DataGridFormatCodeValueKind`

`DataGridFormatCodeDiagnostic`

`DataGridFormatCodeSegment`

`DataGridFormattedCodeValue`

`DataGridFormatCodeConditionOperator`

`DataGridFormatCodeCondition`

`DataGridFormatCodeToken`

`ParsedDataGridFormatCodeSection`

`ParsedDataGridFormatCode`

`resolveDataGridFormatCodeLocale`

`resolveDataGridFormatSectionLocale`

`applyDataGridCellFormatPatch`

`formatWithValuePresentation`

`markDataGridFormatRenderer`

`getDataGridFormatRendererPresentation`

`DATA_GRID_FORMAT_RENDERER`

`isDataGridFormattingRuntimeState`

`cloneDataGridFormattingRuntimeState`

`DataGridValueFormatPreset`

`DataGridFormattingValueKind`

`DataGridPresetValueFormat`

`DataGridCodeValueFormat`

`DataGridValueFormat`

`DataGridCellBorder`

`DataGridCellAppearance`

`DataGridCellPresentation`

`DataGridCellFormat`

`DataGridCellFormatPatch`

`DataGridFormattingPatchTarget`