@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/grid/core/api/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base-types';
+export * from './contracts';
+export * from './live-object-model';

package/dist/types/components/grid/core/api/live-object-model.d.ts

@@ -0,0 +1,186 @@
+import type { ColumnDef, GridColumnGroupDef } from '../types';
+import type { GridColumnGroupRef, GridColumnRef, GridColumnSortState, GridData, GridEventSource, GridLiveObjectEvent, GridLiveObjectEventType, GridLiveObjectKind, GridLiveObjectListener, GridMutationId, GridRefInvalidationReason, GridRowId, GridRowRef } from './contracts';
+export interface GridColumnSnapshot<TData = GridData, TContext = unknown> {
+    id: string;
+    definition: Readonly<ColumnDef<TData, unknown, TContext>>;
+    actualWidth: number | null;
+    visible: boolean;
+    pinned: 'left' | 'right' | null;
+    sort: GridColumnSortState | null;
+    aggFunc: string | null;
+    pivotActive: boolean;
+    parentId: string | null;
+}
+export interface GridColumnGroupSnapshot<TData = GridData, TContext = unknown> {
+    id: string;
+    definition: Readonly<GridColumnGroupDef<TData, TContext>>;
+    childIds: ReadonlyArray<{
+        kind: 'column' | 'columnGroup';
+        id: string;
+    }>;
+    leafIds: readonly string[];
+    parentId: string | null;
+    expanded: boolean;
+    padding: boolean;
+    displayed: boolean;
+}
+export interface GridRowSnapshot<TData = GridData> {
+    id: GridRowId;
+    sourceIndex: number | null;
+    displayIndex: number | null;
+    data: Readonly<TData> | null;
+    parentId: GridRowId | null;
+    childIds: readonly GridRowId[];
+    group: boolean;
+    leaf: boolean;
+    master: boolean;
+    detail: boolean;
+    level: number;
+    route: readonly string[];
+    expandKey?: string | null;
+    selected: boolean;
+    expanded: boolean;
+}
+export type GridLiveMutation<TData = GridData> = {
+    kind: 'column';
+    id: string;
+    type: 'setWidth';
+    value: number;
+} | {
+    kind: 'column';
+    id: string;
+    type: 'setVisible';
+    value: boolean;
+} | {
+    kind: 'column';
+    id: string;
+    type: 'setPinned';
+    value: 'left' | 'right' | null;
+} | {
+    kind: 'column';
+    id: string;
+    type: 'setSort';
+    value: 'asc' | 'desc' | null;
+    multi: boolean;
+} | {
+    kind: 'column';
+    id: string;
+    type: 'setAggFunc';
+    value: string | null;
+} | {
+    kind: 'columnGroup';
+    id: string;
+    type: 'setExpanded';
+    value: boolean;
+} | {
+    kind: 'row';
+    id: GridRowId;
+    type: 'setSelected' | 'setExpanded';
+    value: boolean;
+} | {
+    kind: 'row';
+    id: GridRowId;
+    type: 'setData';
+    value: TData;
+} | {
+    kind: 'row';
+    id: GridRowId;
+    type: 'updateData';
+    value: Partial<TData>;
+} | {
+    kind: 'row';
+    id: GridRowId;
+    type: 'setValue';
+    field: string;
+    value: unknown;
+} | {
+    kind: 'row';
+    id: GridRowId;
+    type: 'setHeight';
+    value: number | null;
+} | {
+    kind: 'row';
+    id: GridRowId;
+    type: 'focus';
+    field?: string;
+} | {
+    kind: 'row';
+    id: GridRowId;
+    type: 'startEditing';
+    field: string;
+};
+export interface GridLiveMutationResult<TData = GridData> {
+    applied: boolean;
+    eventType: GridLiveObjectEventType;
+    before?: unknown;
+    after?: unknown;
+    field?: string;
+    data?: Readonly<TData>;
+}
+export interface GridLiveObjectAdapter<TData = GridData, TContext = unknown> {
+    isConnected(): boolean;
+    columns(): ReadonlyArray<GridColumnSnapshot<TData, TContext>>;
+    columnGroups(): ReadonlyArray<GridColumnGroupSnapshot<TData, TContext>>;
+    rows(): ReadonlyArray<GridRowSnapshot<TData>>;
+    mutate(mutation: GridLiveMutation<TData>, signal: AbortSignal): Promise<GridLiveMutationResult<TData>>;
+    emitGridEvent(event: GridLiveObjectEvent<TData>): void;
+    reportListenerError?(error: unknown, event: GridLiveObjectEvent<TData>): void;
+    columnFilter?: {
+        getModel(colId: string): Promise<unknown>;
+        setModel(colId: string, model: unknown | null): Promise<boolean>;
+    };
+    mintMutationId?(): GridMutationId;
+}
+export interface GridLiveObjectPublication {
+    kind: GridLiveObjectKind;
+    id: string | GridRowId;
+    type: GridLiveObjectEventType;
+    source: GridEventSource;
+    detail?: object;
+}
+declare abstract class LiveRef<TData> {
+    #private;
+    readonly id: string | GridRowId;
+    protected model: GridLiveObjectModel<TData, unknown> | null;
+    generation: number;
+    private listeners;
+    constructor(id: string | GridRowId, model: GridLiveObjectModel<TData, unknown>);
+    abstract readonly kind: GridLiveObjectKind;
+    isValid(): boolean;
+    getInvalidationReason(): GridRefInvalidationReason | null;
+    addEventListener(type: GridLiveObjectEventType | '*', listener: GridLiveObjectListener<TData>): () => void;
+    removeEventListener(type: GridLiveObjectEventType | '*', listener: GridLiveObjectListener<TData>): void;
+    dispatch(event: GridLiveObjectEvent<TData>): void;
+    markInvalid(reason: GridRefInvalidationReason): boolean;
+    dispatchInvalidation(reason: GridRefInvalidationReason): void;
+    protected ensureValid(): void;
+    protected state<TSnapshot>(): TSnapshot | null;
+    protected read<TValue>(field: string, fallback: TValue): TValue;
+    protected mutate(type: string, detail?: object): Promise<boolean>;
+}
+export declare class GridLiveObjectModel<TData = GridData, TContext = unknown> {
+    #private;
+    adapterColumnFilter(): NonNullable<GridLiveObjectAdapter<TData, TContext>['columnFilter']> | null;
+    private states;
+    private pendingMutations;
+    constructor(adapter: GridLiveObjectAdapter<TData, TContext>);
+    reconcile(reason?: GridRefInvalidationReason): void;
+    invalidateAll(reason: GridRefInvalidationReason): void;
+    invalidateRows(reason: GridRefInvalidationReason): void;
+    invalidateRow(id: GridRowId, reason: GridRefInvalidationReason): void;
+    getColumn<TValue = unknown>(id: string): GridColumnRef<TData, TValue, TContext> | null;
+    getColumns(): ReadonlyArray<GridColumnRef<TData, unknown, TContext>>;
+    getColumnGroup(id: string): GridColumnGroupRef<TData, TContext> | null;
+    getColumnGroups(): ReadonlyArray<GridColumnGroupRef<TData, TContext>>;
+    getRow(id: GridRowId): GridRowRef<TData, TContext> | null;
+    getDisplayedRowAtIndex(index: number): GridRowRef<TData, TContext> | null;
+    forEachRow(callback: (row: GridRowRef<TData, TContext>) => void): void;
+    forEachDisplayedRow(callback: (row: GridRowRef<TData, TContext>) => void): void;
+    snapshot(kind: GridLiveObjectKind, id: string | GridRowId): unknown;
+    run(ref: LiveRef<TData>, action: GridLiveMutation<TData>): Promise<boolean>;
+    publish(kind: GridLiveObjectKind, id: string | GridRowId, type: GridLiveObjectEventType, source: GridEventSource, detail?: object): GridLiveObjectEvent<TData>;
+    publishBatch(changes: readonly GridLiveObjectPublication[]): GridLiveObjectEvent<TData>[];
+    reportListenerError(error: unknown, event: GridLiveObjectEvent<TData>): void;
+    publishInvalidation(ref: LiveRef<TData>, reason: GridRefInvalidationReason): void;
+}
+export {};

package/dist/types/components/grid/core/audit/audit-export.d.ts

@@ -0,0 +1,29 @@
+import type { AuditEntry } from './audit-log.ts';
+export declare const AUDIT_CSV_COLUMNS: readonly [
+    "seq",
+    "ts",
+    "kind",
+    "source",
+    "txId",
+    "rowId",
+    "field",
+    "oldValue",
+    "newValue",
+    "added",
+    "updated",
+    "removed",
+    "selectedCount",
+    "addedIds",
+    "removedIds",
+    "action",
+    "undoDepth",
+    "redoDepth"
+];
+export declare function normalizeAuditJsonValue(value: unknown): unknown;
+export interface AuditCsvOptions {
+    readonly delimiter?: string;
+    readonly newline?: string;
+    readonly header?: boolean;
+}
+export declare function auditEntriesToCsv(entries: ReadonlyArray<AuditEntry>, options?: AuditCsvOptions): string;
+export declare function auditEntriesToJson(entries: ReadonlyArray<AuditEntry>, pretty?: boolean): string;

package/dist/types/components/grid/core/audit/audit-log.d.ts

@@ -0,0 +1,70 @@
+export type AuditSource = 'local' | 'remote' | 'undo' | 'redo' | 'clipboard';
+interface AuditEntryCommon {
+    readonly seq: number;
+    readonly ts: number;
+    readonly source: AuditSource;
+}
+export interface AuditRowsEntry extends AuditEntryCommon {
+    readonly kind: 'rows';
+    readonly txId?: number;
+    readonly added: number;
+    readonly updated: number;
+    readonly removed: number;
+}
+export interface AuditCellEntry extends AuditEntryCommon {
+    readonly kind: 'cell';
+    readonly rowId: string | number;
+    readonly field: string;
+    readonly oldValue: unknown;
+    readonly newValue: unknown;
+    readonly txId?: number;
+}
+export interface AuditSelectionEntry extends AuditEntryCommon {
+    readonly kind: 'selection';
+    readonly selectedCount: number;
+    readonly addedIds: ReadonlyArray<string | number>;
+    readonly removedIds: ReadonlyArray<string | number>;
+}
+export interface AuditHistoryEntry extends AuditEntryCommon {
+    readonly kind: 'history';
+    readonly action: 'recorded' | 'undone' | 'redone' | 'cleared';
+    readonly label?: string;
+    readonly undoDepth: number;
+    readonly redoDepth: number;
+}
+export type AuditEntry = AuditRowsEntry | AuditCellEntry | AuditSelectionEntry | AuditHistoryEntry;
+export type AuditEntryInput = (Omit<AuditRowsEntry, 'seq' | 'ts'> & {
+    ts?: number;
+}) | (Omit<AuditCellEntry, 'seq' | 'ts'> & {
+    ts?: number;
+}) | (Omit<AuditSelectionEntry, 'seq' | 'ts'> & {
+    ts?: number;
+}) | (Omit<AuditHistoryEntry, 'seq' | 'ts'> & {
+    ts?: number;
+});
+export interface AuditLogFilter {
+    readonly kind?: AuditEntry['kind'] | ReadonlyArray<AuditEntry['kind']>;
+    readonly source?: AuditSource | ReadonlyArray<AuditSource>;
+    readonly sinceSeq?: number;
+    readonly sinceTs?: number;
+}
+export interface AuditLogOptions {
+    readonly maxEntries?: number;
+    readonly now?: () => number;
+}
+export declare class AuditLog {
+    private maxEntries;
+    private readonly now;
+    private buf;
+    private seqCounter;
+    private recordedCount;
+    constructor(options?: AuditLogOptions);
+    record(input: AuditEntryInput): AuditEntry;
+    entries(filter?: AuditLogFilter): readonly AuditEntry[];
+    size(): number;
+    totalRecorded(): number;
+    last(): AuditEntry | null;
+    resize(maxEntries: number): void;
+    clear(): void;
+}
+export {};

package/dist/types/components/grid/core/brand/grid-brand.d.ts

@@ -0,0 +1,12 @@
+import type { BrandDecision, BrandLogoRequest } from '../../../_shared/brand/types';
+export declare const GRID_BRAND_FEATURE: "chart.branding" | "grid.branding";
+export declare const GRID_BRAND_MEMBER = "brandLogo";
+export declare class GridBrand {
+    private value;
+    private request;
+    private last;
+    requestFor(value: unknown): BrandLogoRequest;
+    needsEntitlement(value: unknown): boolean;
+    decide(value: unknown, entitlement: () => string, pendingTimedOut?: boolean): BrandDecision;
+}
+export declare function gridBrandProblem(decision: BrandDecision | null | undefined, tag?: string): string | null;

package/dist/types/components/grid/core/build-tier.d.ts

@@ -0,0 +1,3 @@
+export type GridBuildTier = 'community' | 'pro';
+export declare const GRID_BUILD_TIER: GridBuildTier;
+export declare const GRID_FORMULA_WASM_DIAGNOSTICS = true;

package/dist/types/components/grid/core/cell/cell-class-rules.d.ts

@@ -0,0 +1,57 @@
+import type { ColumnDef } from '../types';
+export interface CellClassRuleParams<TRow = Record<string, unknown>> {
+    value: unknown;
+    data: TRow;
+    node: {
+        rowIndex: number;
+    };
+    colId: string;
+    formatted?: string;
+    colDef?: ColumnDef;
+    context?: unknown;
+    api?: unknown;
+}
+export type CellClassRuleFn<TRow = Record<string, unknown>> = (params: CellClassRuleParams<TRow>) => boolean;
+export type CellClassRules<TRow = Record<string, unknown>> = Record<string, CellClassRuleFn<TRow> | string>;
+export type CellClassFn<TRow = Record<string, unknown>> = (params: CellClassRuleParams<TRow>) => string;
+export interface CellClassRulesInput<TRow = Record<string, unknown>> {
+    value: unknown;
+    formatted?: string;
+    row: TRow;
+    rowIndex: number;
+    colId: string;
+    cellClassRules?: CellClassRules<TRow>;
+    cellClass?: string | string[] | CellClassFn<TRow>;
+    colDef?: ColumnDef;
+    context?: unknown;
+    api?: unknown;
+}
+export type RuleExpressionNode = {
+    kind: 'number';
+    value: number;
+} | {
+    kind: 'string';
+    value: string;
+} | {
+    kind: 'identifier';
+    name: string;
+} | {
+    kind: 'binary';
+    op: '+' | '-' | '*' | '/' | '>' | '<' | '>=' | '<=' | '==' | '!=' | '&&' | '||';
+    left: RuleExpressionNode;
+    right: RuleExpressionNode;
+} | {
+    kind: 'unary';
+    op: '-';
+    operand: RuleExpressionNode;
+} | {
+    kind: 'group';
+    inner: RuleExpressionNode;
+};
+export interface ParsedRuleExpression {
+    ast: RuleExpressionNode;
+    identifiers: ReadonlyArray<string>;
+}
+export declare function parseCellClassRuleExpression(expr: string): ParsedRuleExpression;
+export declare function evaluateCellClassRule<TRow = Record<string, unknown>>(rule: CellClassRuleFn<TRow> | string, params: CellClassRuleParams<TRow>): boolean;
+export declare function applyCellClassRules<TRow = Record<string, unknown>>(input: CellClassRulesInput<TRow>): string;

package/dist/types/components/grid/core/cell/cell-style.d.ts

@@ -0,0 +1,36 @@
+import type { ColumnDef } from '../types';
+export interface CellStyleParams<TRow = Record<string, unknown>> {
+    value: unknown;
+    data: TRow;
+    node: {
+        rowIndex: number;
+    };
+    colId: string;
+    formatted?: string;
+    colDef?: ColumnDef;
+    context?: unknown;
+    api?: unknown;
+}
+export type CellStyleFn<TRow = Record<string, unknown>> = (params: CellStyleParams<TRow>) => Record<string, string | number> | null | undefined;
+export type CellStyleSpec<TRow = Record<string, unknown>> = Record<string, string | number> | CellStyleFn<TRow> | ReadonlyArray<CellStyleSpec<TRow>>;
+export interface CellStyleInput<TRow = Record<string, unknown>> {
+    value: unknown;
+    formatted?: string;
+    row: TRow;
+    rowIndex: number;
+    colId: string;
+    cellStyle?: CellStyleSpec<TRow>;
+    colDef?: ColumnDef;
+    context?: unknown;
+    api?: unknown;
+}
+export interface CellStyleResult {
+    style: Record<string, string>;
+    meta: {
+        kind: 'object' | 'function' | 'array' | 'none';
+        appliedKeys: number;
+    };
+}
+export declare function validateCssKey(key: unknown): boolean;
+export declare function mergeCellStyles(specs: ReadonlyArray<Record<string, string>>): Record<string, string>;
+export declare function applyCellStyle<TRow = Record<string, unknown>>(input: CellStyleInput<TRow>): CellStyleResult;

package/dist/types/components/grid/core/cell/expression-runtime.d.ts

@@ -0,0 +1,29 @@
+export type GridExpressionNode = {
+    kind: 'number';
+    value: number;
+} | {
+    kind: 'string';
+    value: string;
+} | {
+    kind: 'identifier';
+    name: string;
+} | {
+    kind: 'binary';
+    op: '+' | '-' | '*' | '/' | '>' | '<' | '>=' | '<=' | '==' | '!=' | '&&' | '||';
+    left: GridExpressionNode;
+    right: GridExpressionNode;
+} | {
+    kind: 'unary';
+    op: '-';
+    operand: GridExpressionNode;
+} | {
+    kind: 'group';
+    inner: GridExpressionNode;
+};
+export interface ParsedGridExpression {
+    ast: GridExpressionNode;
+    identifiers: ReadonlyArray<string>;
+}
+export declare function warnGridExpression(code: string, field: string, row: number, detail?: string, cause?: unknown): void;
+export declare function parseGridExpression(expr: string, allowRuleOperators: boolean): ParsedGridExpression;
+export declare function evaluateGridExpression(ast: GridExpressionNode, getIdentifier: (name: string) => unknown): unknown;

package/dist/types/components/grid/core/cell/index.d.ts

@@ -0,0 +1,5 @@
+export * from './renderer-registry';
+export * from './value-getter';
+export * from './value-formatter';
+export * from './cell-class-rules';
+export * from './cell-style';

package/dist/types/components/grid/core/cell/renderer-registry.d.ts

@@ -0,0 +1,55 @@
+export interface CellRendererInput<TRow = Record<string, unknown>, TValue = unknown> {
+    value: TValue;
+    row: TRow;
+    rowIndex: number;
+    colIndex: number;
+    colId: string;
+    formatted?: string;
+    meta?: Record<string, unknown>;
+}
+export type CellRenderOutput = {
+    kind: 'text';
+    text: string;
+    class?: string;
+    title?: string;
+} | {
+    kind: 'html';
+    html: string;
+    class?: string;
+    title?: string;
+} | {
+    kind: 'vnode';
+    vnode: unknown;
+    class?: string;
+    title?: string;
+};
+export type CellRenderer<TRow = Record<string, unknown>, TValue = unknown> = (input: CellRendererInput<TRow, TValue>) => CellRenderOutput;
+export type NormalizedRenderOutput = {
+    kind: 'text';
+    text: string;
+    class: string;
+} | {
+    kind: 'html';
+    html: string;
+    class: string;
+} | {
+    kind: 'vnode';
+    vnode: unknown;
+} | {
+    kind: 'invalid';
+};
+export declare function normalizeRenderOutput(output: unknown): NormalizedRenderOutput;
+export interface RendererRegistry<TRow = Record<string, unknown>, TValue = unknown> {
+    register(name: string, renderer: CellRenderer<TRow, TValue>): boolean;
+    replace(name: string, renderer: CellRenderer<TRow, TValue>): boolean;
+    unregister(name: string): boolean;
+    get(name: string): CellRenderer<TRow, TValue> | null;
+    has(name: string): boolean;
+    list(): ReadonlyArray<string>;
+    clear(): void;
+}
+export interface CreateRendererRegistryOptions {
+    includeBuiltins?: boolean;
+}
+export declare function createRendererRegistry<TRow = Record<string, unknown>, TValue = unknown>(opts?: CreateRendererRegistryOptions): RendererRegistry<TRow, TValue>;
+export declare const BUILTIN_RENDERER_NAMES: ReadonlyArray<string>;

package/dist/types/components/grid/core/cell/value-formatter.d.ts

@@ -0,0 +1,42 @@
+import type { ColumnDef } from '../types';
+export interface ValueFormatterParams<TRow = Record<string, unknown>> {
+    value: unknown;
+    data: TRow;
+    node: {
+        rowIndex: number;
+    };
+    colId: string;
+    locale: string;
+    context?: unknown;
+    api?: unknown;
+}
+export type ValueFormatter<TRow = Record<string, unknown>> = ((params: ValueFormatterParams<TRow>) => string) | string;
+export interface ValueFormatterInput<TRow = Record<string, unknown>> {
+    value: unknown;
+    row: TRow;
+    rowIndex: number;
+    colId: string;
+    valueFormatter?: ValueFormatter<TRow>;
+    locale?: string;
+    colDef?: ColumnDef;
+    context?: unknown;
+    api?: unknown;
+}
+export interface PipeApplication {
+    name: string;
+    args: ReadonlyArray<string>;
+}
+export type TemplateSegment = {
+    kind: 'literal';
+    text: string;
+} | {
+    kind: 'interp';
+    varName: string;
+    pipes: ReadonlyArray<PipeApplication>;
+};
+export interface ParsedTemplate {
+    segments: ReadonlyArray<TemplateSegment>;
+}
+export declare function parseValueFormatterTemplate(template: string): ParsedTemplate;
+export declare function applyPipes(value: unknown, pipes: ReadonlyArray<PipeApplication>, locale: string): string;
+export declare function formatCellValue<TRow = Record<string, unknown>>(input: ValueFormatterInput<TRow>): string;

package/dist/types/components/grid/core/cell/value-getter.d.ts

@@ -0,0 +1,59 @@
+import type { ColumnDef } from '../types';
+export interface CellValueGetterParams<TRow = Record<string, unknown>> {
+    data: TRow;
+    node: {
+        rowIndex: number;
+        rowId?: string | number;
+    };
+    colId: string;
+    getValue: (otherColId: string) => unknown;
+    colDef?: ColumnDef;
+    rowIndex: number;
+    context?: unknown;
+    api?: unknown;
+}
+export type ValueGetter<TRow = Record<string, unknown>> = ((params: CellValueGetterParams<TRow>) => unknown) | string;
+export interface ValueGetterInput<TRow = Record<string, unknown>> {
+    row: TRow;
+    rowIndex: number;
+    colId: string;
+    valueGetter?: ValueGetter<TRow>;
+    field?: string;
+    getOtherValue?: (otherColId: string) => unknown;
+    rowId?: string | number;
+    colDef?: ColumnDef;
+    inFlight?: Set<string>;
+    context?: unknown;
+    api?: unknown;
+}
+export type ExpressionNode = {
+    kind: 'number';
+    value: number;
+} | {
+    kind: 'string';
+    value: string;
+} | {
+    kind: 'identifier';
+    name: string;
+} | {
+    kind: 'binary';
+    op: '+' | '-' | '*' | '/';
+    left: ExpressionNode;
+    right: ExpressionNode;
+} | {
+    kind: 'unary';
+    op: '-';
+    operand: ExpressionNode;
+} | {
+    kind: 'group';
+    inner: ExpressionNode;
+};
+export interface ParsedExpression {
+    ast: ExpressionNode;
+    identifiers: ReadonlyArray<string>;
+}
+export declare function readOwnFieldPath(row: unknown, path: string): unknown;
+export declare function setOwnFieldPathImmutable<TRoot>(root: TRoot, path: string, value: unknown): TRoot;
+export declare function parseValueGetterExpression(expr: string): ParsedExpression;
+export declare function evaluateExpression(ast: ExpressionNode, getIdentifier: (name: string) => unknown): unknown;
+export declare function resolveCellValue<TRow = Record<string, unknown>>(input: ValueGetterInput<TRow>): unknown;

package/dist/types/components/grid/core/cell-cycle.d.ts

@@ -0,0 +1,19 @@
+export interface ActiveCell {
+    rowIndex: number;
+    colIndex: number;
+}
+export interface CellNavInputs {
+    active: ActiveCell | null;
+    rowCount: number;
+    colCount: number;
+}
+export type MoveDirection = 'up' | 'down' | 'left' | 'right';
+export declare function moveCell(active: ActiveCell | null, direction: MoveDirection, rowCount: number, colCount: number): ActiveCell | null;
+export declare function tabCell(active: ActiveCell | null, reverse: boolean, rowCount: number, colCount: number): ActiveCell | null;
+export declare function clampCell(active: ActiveCell | null, rowCount: number, colCount: number): ActiveCell | null;
+export declare function homeCell(active: ActiveCell | null, colCount: number): ActiveCell | null;
+export declare function endCell(active: ActiveCell | null, colCount: number): ActiveCell | null;
+export declare function homeGridCell(rowCount: number, colCount: number): ActiveCell | null;
+export declare function endGridCell(rowCount: number, colCount: number): ActiveCell | null;
+export declare function pageCell(active: ActiveCell | null, direction: 'up' | 'down', pageSize: number, rowCount: number, colCount: number): ActiveCell | null;
+export declare function moveCellWithWrap(active: ActiveCell | null, direction: MoveDirection, rowCount: number, colCount: number): ActiveCell | null;

package/dist/types/components/grid/core/cell-flash/cell-flash.d.ts

@@ -0,0 +1,4 @@
+export declare function cellFlashKey(rowIndex: number, field: string): string;
+export declare function addFlash(set: ReadonlySet<string>, key: string): ReadonlySet<string>;
+export declare function removeFlash(set: ReadonlySet<string>, key: string): ReadonlySet<string>;
+export declare function hasFlash(set: ReadonlySet<string>, key: string): boolean;

package/dist/types/components/grid/core/cell-tooltip/hover-delay.d.ts

@@ -0,0 +1,15 @@
+export interface HoverDelayOptions<T> {
+    showMs?: number;
+    hideMs?: number;
+    onShow: (target: T) => void;
+    onHide: () => void;
+    schedule?: (fn: () => void, ms: number) => unknown;
+    cancel?: (handle: unknown) => void;
+}
+export interface HoverDelayController<T> {
+    enter(target: T): void;
+    leave(): void;
+    cancel(): void;
+    readonly state: 'idle' | 'pending-show' | 'shown' | 'pending-hide';
+}
+export declare function createHoverDelay<T>(options: HoverDelayOptions<T>): HoverDelayController<T>;

package/dist/types/components/grid/core/cell-tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tooltip-text';
+export * from './hover-delay';

package/dist/types/components/grid/core/cell-tooltip/tooltip-text.d.ts

@@ -0,0 +1,16 @@
+import type { ColumnDef } from '../types';
+export interface TooltipColumn extends Pick<ColumnDef, 'field' | 'valueGetter' | 'valueFormatter'> {
+    tooltipField?: string;
+    tooltipValueGetter?: ColumnDef['valueGetter'];
+}
+export interface GetCellTooltipTextOptions<TRow = Record<string, unknown>> {
+    row: TRow;
+    rowIndex: number;
+    column: TooltipColumn;
+    displayedText?: string;
+    isOverflowing?: boolean;
+    locale?: string;
+    context?: unknown;
+    api?: unknown;
+}
+export declare function getCellTooltipText<TRow = Record<string, unknown>>(options: GetCellTooltipTextOptions<TRow>): string;