@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/grid/core/row-layout/pinned-row-policy.d.ts

@@ -0,0 +1,142 @@
+import type { PinnedRow, PinnedRowModel, PinnedRowSection } from './pinned-rows.ts';
+import type { SyGridRowId } from '../state/slices/ui.ts';
+export type PinnedRowBand = 'top' | 'center' | 'bottom';
+export declare const PINNED_ROW_BANDS: readonly [
+    "top",
+    "center",
+    "bottom"
+];
+export interface DisplayRowAddress<TData = unknown> {
+    readonly band: PinnedRowBand;
+    readonly displayIndex: number;
+    readonly centerIndex: number | null;
+    readonly row: PinnedRow<TData> | null;
+    readonly sectionIndex: number | null;
+}
+export declare function displayRowCount(model: PinnedRowModel<unknown>, centerRowCount: number): number;
+export declare function addressDisplayRow<TData>(model: PinnedRowModel<TData>, centerRowCount: number, displayIndex: number): DisplayRowAddress<TData> | null;
+export declare function pinnedRowDisplayIndex(model: PinnedRowModel<unknown>, id: SyGridRowId, centerRowCount: number): number;
+export declare function centerRowDisplayIndex(model: PinnedRowModel<unknown>, centerIndex: number): number;
+export declare function isPinnedDisplayIndex(model: PinnedRowModel<unknown>, centerRowCount: number, displayIndex: number): boolean;
+export type PinnedRowFeature = 'row-selection' | 'range-selection' | 'cell-edit' | 'row-edit' | 'fill' | 'clipboard-copy' | 'clipboard-paste' | 'export-csv' | 'export-xlsx' | 'export-pdf' | 'formula-evaluate' | 'formula-reference' | 'rbac-read' | 'rbac-write' | 'keyboard-navigate';
+export declare const PINNED_ROW_FEATURES: readonly [
+    "row-selection",
+    "range-selection",
+    "cell-edit",
+    "row-edit",
+    "fill",
+    "clipboard-copy",
+    "clipboard-paste",
+    "export-csv",
+    "export-xlsx",
+    "export-pdf",
+    "formula-evaluate",
+    "formula-reference",
+    "rbac-read",
+    "rbac-write",
+    "keyboard-navigate"
+];
+export type PinnedRowSupport = 'supported' | 'unsupported' | 'delegated';
+export type PinnedRowPolicyReason = 'own-data' | 'identity-keyed' | 'host-owned' | 'band-aware' | 'ambiguous-row-id' | 'id-collision' | 'display-index-addressed' | 'no-source-row' | 'not-in-source' | 'pinned-boundary' | 'no-sheet-anchor' | 'would-shift-addresses' | 'out-of-range';
+export declare const PINNED_ROW_POLICY_REASONS: readonly [
+    "own-data",
+    "identity-keyed",
+    "host-owned",
+    "band-aware",
+    "ambiguous-row-id",
+    "id-collision",
+    "display-index-addressed",
+    "no-source-row",
+    "not-in-source",
+    "pinned-boundary",
+    "no-sheet-anchor",
+    "would-shift-addresses",
+    "out-of-range"
+];
+export type PinnedRowDelegateKey = 'row-id' | 'pinned-address';
+export interface PinnedRowPolicyDecision {
+    readonly feature: PinnedRowFeature;
+    readonly support: PinnedRowSupport;
+    readonly reason: PinnedRowPolicyReason;
+    readonly detail: string;
+    readonly delegateKey: PinnedRowDelegateKey | null;
+    readonly mutating: boolean;
+}
+export interface PinnedRowPolicyContext {
+    readonly stableRowIds: boolean;
+    readonly idCollisions: number;
+}
+export declare const STRICT_PINNED_ROW_CONTEXT: PinnedRowPolicyContext;
+export declare function pinnedRowIdCollisions<TData, TRow>(model: PinnedRowModel<TData>, rows: readonly TRow[], getRowId: (row: TRow) => SyGridRowId): readonly SyGridRowId[];
+export declare function pinnedRowPolicy(feature: PinnedRowFeature, context?: PinnedRowPolicyContext): PinnedRowPolicyDecision;
+export declare function pinnedRowPolicyMatrix(context?: PinnedRowPolicyContext): readonly PinnedRowPolicyDecision[];
+export interface PinnedRowRefusal {
+    readonly feature: PinnedRowFeature | null;
+    readonly reason: PinnedRowPolicyReason;
+    readonly band: PinnedRowBand | null;
+    readonly displayIndex: number;
+    readonly id: SyGridRowId | null;
+    readonly detail: string;
+}
+export type PinnedRowGuardResult = {
+    readonly ok: true;
+    readonly centerIndex: number;
+} | {
+    readonly ok: false;
+    readonly refusal: PinnedRowRefusal;
+};
+export declare function resolvePipelineRowIndex<TData>(model: PinnedRowModel<TData>, centerRowCount: number, displayIndex: number): PinnedRowGuardResult;
+export type PinnedRowPlan<TData = unknown> = {
+    readonly outcome: 'pipeline';
+    readonly address: DisplayRowAddress<TData>;
+    readonly centerIndex: number;
+} | {
+    readonly outcome: 'pinned';
+    readonly address: DisplayRowAddress<TData>;
+    readonly decision: PinnedRowPolicyDecision;
+} | {
+    readonly outcome: 'refused';
+    readonly address: DisplayRowAddress<TData> | null;
+    readonly decision: PinnedRowPolicyDecision | null;
+    readonly refusal: PinnedRowRefusal;
+};
+export declare function planPinnedRowOperation<TData>(model: PinnedRowModel<TData>, centerRowCount: number, feature: PinnedRowFeature, displayIndex: number, context?: PinnedRowPolicyContext): PinnedRowPlan<TData>;
+export interface DisplayRowPartition<TData = unknown> {
+    readonly top: readonly DisplayRowAddress<TData>[];
+    readonly center: {
+        readonly startIndex: number;
+        readonly endIndex: number;
+    } | null;
+    readonly bottom: readonly DisplayRowAddress<TData>[];
+    readonly crossesBands: boolean;
+    readonly outOfRange: readonly number[];
+}
+export declare function partitionDisplayRange<TData>(model: PinnedRowModel<TData>, centerRowCount: number, fromIndex: number, toIndex: number): DisplayRowPartition<TData>;
+export type PinnedRowNavDirection = 'up' | 'down' | 'home' | 'end' | 'page-up' | 'page-down';
+export declare const PINNED_ROW_NAV_DIRECTIONS: readonly [
+    "up",
+    "down",
+    "home",
+    "end",
+    "page-up",
+    "page-down"
+];
+export interface PinnedRowNavigation<TData = unknown> {
+    readonly from: DisplayRowAddress<TData>;
+    readonly to: DisplayRowAddress<TData>;
+    readonly moved: boolean;
+    readonly crossedBand: boolean;
+}
+export declare function navigatePinnedRows<TData>(model: PinnedRowModel<TData>, centerRowCount: number, displayIndex: number, direction: PinnedRowNavDirection, pageSize?: number): PinnedRowNavigation<TData> | null;
+export interface PinnedRowIntegrationReport {
+    readonly topCount: number;
+    readonly centerCount: number;
+    readonly bottomCount: number;
+    readonly displayCount: number;
+    readonly idCollisions: readonly SyGridRowId[];
+    readonly unsupported: readonly PinnedRowPolicyDecision[];
+    readonly delegated: readonly PinnedRowPolicyDecision[];
+    readonly supported: readonly PinnedRowPolicyDecision[];
+}
+export declare function pinnedRowIntegrationReport<TData, TRow>(model: PinnedRowModel<TData>, rows: readonly TRow[], getRowId: (row: TRow) => SyGridRowId, context?: PinnedRowPolicyContext): PinnedRowIntegrationReport;
+export declare const PINNED_ROW_SECTIONS: readonly PinnedRowSection[];

package/dist/types/components/grid/core/row-layout/pinned-rows-facade.d.ts

@@ -0,0 +1,72 @@
+import type { SyGridPinnedRowsSlice, SyGridRowId } from '../state/slices/ui';
+import type { PinnedRow, PinnedRowChange, PinnedRowModel, PinnedRowRejection, PinnedRowSection, PinnedRowSetInput } from './pinned-rows';
+import type { DisplayRowAddress, PinnedRowFeature, PinnedRowIntegrationReport, PinnedRowNavDirection, PinnedRowPolicyDecision } from './pinned-row-policy';
+export interface PinnedRowsHost<TRow> {
+    readonly displayRows: () => readonly TRow[];
+    readonly sourceRows: () => readonly TRow[];
+    readonly rowIdOf: ((row: TRow) => SyGridRowId | undefined) | null;
+}
+export interface PinnedRowFocus {
+    readonly band: PinnedRowSection;
+    readonly sectionIndex: number;
+    readonly colIndex: number;
+}
+export type PinnedRowNavTarget = {
+    readonly kind: 'band';
+    readonly band: PinnedRowSection;
+    readonly sectionIndex: number;
+} | {
+    readonly kind: 'center';
+    readonly rowIndex: number;
+};
+export interface PinnedRowNavResult {
+    readonly target: PinnedRowNavTarget;
+    readonly moved: boolean;
+    readonly crossedBand: boolean;
+}
+export interface PinnedRowsSetOutcome<TRow> {
+    readonly status: 'applied' | 'unchanged' | 'refused';
+    readonly changes: readonly PinnedRowChange<TRow>[];
+    readonly rejected: readonly PinnedRowRejection[];
+    readonly top: readonly SyGridRowId[];
+    readonly bottom: readonly SyGridRowId[];
+}
+export interface PinnedRowsRestoreOutcome<TRow> extends PinnedRowsSetOutcome<TRow> {
+    readonly dropped: readonly SyGridRowId[];
+}
+export interface PinnedRowsFacade<TRow> {
+    model(): PinnedRowModel<TRow>;
+    version(): number;
+    rows(section: PinnedRowSection): readonly PinnedRow<TRow>[];
+    count(): number;
+    setPinned(input: PinnedRowSetInput<TRow>): PinnedRowsSetOutcome<TRow>;
+    address(displayIndex: number): DisplayRowAddress<TRow> | null;
+    composedIndex(focus: PinnedRowFocus | null, centerRowIndex: number | null): number | null;
+    navigate(focus: PinnedRowFocus | null, centerRowIndex: number | null, direction: PinnedRowNavDirection, pageSize?: number): PinnedRowNavResult | null;
+    policy(feature: PinnedRowFeature): PinnedRowPolicyDecision;
+    allows(feature: PinnedRowFeature): boolean;
+    report(): PinnedRowIntegrationReport;
+    toSlice(): SyGridPinnedRowsSlice;
+    restoreSlice(slice: SyGridPinnedRowsSlice): PinnedRowsRestoreOutcome<TRow>;
+    dangling(): readonly SyGridRowId[];
+}
+export declare function createPinnedRowsFacade<TRow>(host: PinnedRowsHost<TRow>): PinnedRowsFacade<TRow>;
+export declare function pinnedDisplayRowCount(model: PinnedRowModel<unknown>, centerRowCount: number): number;
+export interface PinnedBandCellHost<TRow, TColumn> {
+    readonly rawValue: (row: TRow, sectionIndex: number, column: TColumn) => unknown;
+    readonly readable: (raw: unknown, row: TRow, sectionIndex: number, column: TColumn) => boolean;
+    readonly maskedValue: unknown;
+    readonly maskedRow: (row: TRow, sectionIndex: number) => TRow;
+    readonly value: (row: TRow, sectionIndex: number, column: TColumn) => unknown;
+    readonly format: (value: unknown, row: TRow, sectionIndex: number, column: TColumn) => string;
+    readonly classRules: (value: unknown, formatted: string | undefined, row: TRow, sectionIndex: number, column: TColumn) => string;
+    readonly styleRules: (value: unknown, formatted: string | undefined, row: TRow, sectionIndex: number, column: TColumn) => Record<string, string>;
+}
+export interface PinnedBandCellPaint {
+    readonly display: string;
+    readonly classes: Record<string, boolean>;
+    readonly style: Record<string, string>;
+}
+export declare function paintPinnedBandCell<TRow, TColumn extends {
+    readonly valueFormatter?: unknown;
+}>(host: PinnedBandCellHost<TRow, TColumn>, row: TRow, sectionIndex: number, column: TColumn): PinnedBandCellPaint;

package/dist/types/components/grid/core/row-layout/pinned-rows.d.ts

@@ -0,0 +1,116 @@
+import type { SyGridPinnedRowsSlice, SyGridRowId } from '../state/slices/ui.ts';
+export type PinnedRowSection = 'top' | 'bottom';
+export interface PinnedRowInput<TData = unknown> {
+    readonly id: SyGridRowId;
+    readonly data: TData;
+}
+export interface PinnedRow<TData = unknown> {
+    readonly id: SyGridRowId;
+    readonly section: PinnedRowSection;
+    readonly pinSeq: number;
+    readonly rev: number;
+    readonly data: TData;
+}
+export interface PinnedRowModel<TData = unknown> {
+    readonly top: readonly PinnedRow<TData>[];
+    readonly bottom: readonly PinnedRow<TData>[];
+    readonly nextSeq: number;
+}
+export interface PinnedRowLocation<TData = unknown> {
+    readonly row: PinnedRow<TData>;
+    readonly section: PinnedRowSection;
+    readonly index: number;
+}
+export interface PinnedRowRef {
+    readonly id: SyGridRowId;
+    readonly pinSeq: number;
+}
+export type PinnedRowChange<TData = unknown> = {
+    readonly kind: 'pinned';
+    readonly id: SyGridRowId;
+    readonly section: PinnedRowSection;
+    readonly index: number;
+    readonly row: PinnedRow<TData>;
+} | {
+    readonly kind: 'unpinned';
+    readonly id: SyGridRowId;
+    readonly section: PinnedRowSection;
+    readonly index: number;
+    readonly row: PinnedRow<TData>;
+} | {
+    readonly kind: 'moved';
+    readonly id: SyGridRowId;
+    readonly from: {
+        readonly section: PinnedRowSection;
+        readonly index: number;
+    };
+    readonly to: {
+        readonly section: PinnedRowSection;
+        readonly index: number;
+    };
+    readonly row: PinnedRow<TData>;
+} | {
+    readonly kind: 'updated';
+    readonly id: SyGridRowId;
+    readonly section: PinnedRowSection;
+    readonly index: number;
+    readonly row: PinnedRow<TData>;
+    readonly previous: PinnedRow<TData>;
+};
+export declare const PINNED_ROW_CHANGE_KINDS: readonly [
+    "pinned",
+    "unpinned",
+    "moved",
+    "updated"
+];
+export type PinnedRowRejectionReason = 'invalid-id' | 'already-pinned' | 'duplicate-id' | 'section-conflict' | 'unknown-id' | 'invalid-slice';
+export interface PinnedRowRejection {
+    readonly reason: PinnedRowRejectionReason;
+    readonly id: SyGridRowId | null;
+    readonly detail: string;
+}
+export interface PinnedRowOpResult<TData = unknown> {
+    readonly model: PinnedRowModel<TData>;
+    readonly changes: readonly PinnedRowChange<TData>[];
+    readonly rejected: readonly PinnedRowRejection[];
+}
+export interface PinnedRowSetInput<TData = unknown> {
+    readonly top?: readonly PinnedRowInput<TData>[];
+    readonly bottom?: readonly PinnedRowInput<TData>[];
+}
+export interface PinnedRowUpdate<TData = unknown> {
+    readonly id: SyGridRowId;
+    readonly data: TData;
+}
+export interface PinnedRowResolved<TData = unknown, TRow = unknown> extends PinnedRowLocation<TData> {
+    readonly dataRow: TRow;
+}
+export interface PinnedRowResolution<TData = unknown, TRow = unknown> {
+    readonly resolved: readonly PinnedRowResolved<TData, TRow>[];
+    readonly dangling: readonly PinnedRowLocation<TData>[];
+}
+export interface PinnedRowLayout<TData = unknown, TRow = unknown> {
+    readonly top: readonly PinnedRow<TData>[];
+    readonly center: readonly TRow[];
+    readonly bottom: readonly PinnedRow<TData>[];
+}
+export declare function createPinnedRowModel<TData = unknown>(): PinnedRowModel<TData>;
+export declare function pinnedRowCount(model: PinnedRowModel<unknown>): number;
+export declare function findPinnedRow<TData>(model: PinnedRowModel<TData>, id: SyGridRowId): PinnedRowLocation<TData> | null;
+export declare function pinnedRowRef(model: PinnedRowModel<unknown>, id: SyGridRowId): PinnedRowRef | null;
+export declare function isPinnedRowRefLive(model: PinnedRowModel<unknown>, ref: PinnedRowRef): boolean;
+export declare function layoutWithPinnedRows<TData, TRow>(model: PinnedRowModel<TData>, displayRows: readonly TRow[]): PinnedRowLayout<TData, TRow>;
+export declare function pinRow<TData>(model: PinnedRowModel<TData>, entry: PinnedRowInput<TData>, options?: {
+    readonly section?: PinnedRowSection;
+    readonly index?: number;
+}): PinnedRowOpResult<TData>;
+export declare function unpinRow<TData>(model: PinnedRowModel<TData>, id: SyGridRowId): PinnedRowOpResult<TData>;
+export declare function movePinnedRow<TData>(model: PinnedRowModel<TData>, id: SyGridRowId, target?: {
+    readonly section?: PinnedRowSection;
+    readonly index?: number;
+}): PinnedRowOpResult<TData>;
+export declare function applyPinnedRowUpdates<TData>(model: PinnedRowModel<TData>, updates: readonly PinnedRowUpdate<TData>[]): PinnedRowOpResult<TData>;
+export declare function replacePinnedRows<TData>(model: PinnedRowModel<TData>, next: PinnedRowSetInput<TData>): PinnedRowOpResult<TData>;
+export declare function resolvePinnedRows<TData, TRow>(model: PinnedRowModel<TData>, rows: readonly TRow[], getRowId: (row: TRow) => SyGridRowId): PinnedRowResolution<TData, TRow>;
+export declare function toPinnedRowsSlice(model: PinnedRowModel<unknown>): SyGridPinnedRowsSlice;
+export declare function fromPinnedRowsSlice<TData>(slice: SyGridPinnedRowsSlice, resolveData: (id: SyGridRowId) => TData | undefined): PinnedRowOpResult<TData>;

package/dist/types/components/grid/core/row-layout/row-layout-chunk.d.ts

@@ -0,0 +1,11 @@
+export * from './row-span';
+export * from './col-span';
+export * from './span-interaction';
+export * from './row-layout-facade';
+export * from './pinned-rows';
+export * from './pinned-row-policy';
+export * from './pinned-rows-facade';
+export * from './full-width-rows';
+export * from './full-width-facade';
+export * from './aligned-grids';
+export * from './aligned-grids-facade';

package/dist/types/components/grid/core/row-layout/row-layout-facade.d.ts

@@ -0,0 +1,143 @@
+import type { ColumnDef } from '../types';
+import { measureRowSpanGeometry, type RowSpanCache, type RowSpanCacheStats, type RowSpanCallback, type RowSpanInvalidationReason, type RowSpanLayout, type RowSpanRejection, type RowSpanSectionKey, type RowSpanWindow } from './row-span';
+import { type ColSpanCallback, type ColSpanContainer, type ColSpanLayout, type ColSpanRejection } from './col-span';
+import { type SpanAccess, type SpanAddress, type SpanConflict, type SpanExportMode, type SpanFeature, type SpanGrid, type SpanGridReport, type SpanNavDirection, type SpanRange, type SpanRect, type SpanValueMatrix } from './span-interaction';
+export declare const ROW_SPAN_MAX = 100;
+export type RowLayoutStatus = 'ok' | 'not-configured' | 'not-client-side' | 'auto-height';
+export interface RowLayoutHostView<TRow, TColumn extends ColumnDef = ColumnDef> {
+    readonly rows: readonly TRow[];
+    readonly columns: readonly TColumn[];
+    readonly rowSpanOf: (column: TColumn) => RowSpanCallback<TRow, TColumn> | null;
+    readonly colSpanOf: (column: TColumn) => ColSpanCallback<TRow, TColumn> | null;
+    readonly sectionKeyOf: (row: TRow, index: number) => RowSpanSectionKey;
+    readonly containerOf: (column: TColumn, index: number) => ColSpanContainer;
+    readonly rowHeightAt: (index: number) => number;
+    readonly widthOf: (column: TColumn, index: number) => number | null;
+    readonly clientSide: boolean;
+    readonly autoHeight: boolean;
+}
+export interface RowSpanCapRejection {
+    readonly reason: 'clamped-to-max';
+    readonly index: number;
+    readonly requested: number;
+    readonly applied: number;
+    readonly detail: string;
+}
+export type RowLayoutRejection = RowSpanRejection | RowSpanCapRejection;
+export interface RowLayoutState<TRow, TColumn extends ColumnDef = ColumnDef> {
+    readonly rowSpanCache: RowSpanCache<TRow, TColumn>;
+    readonly clampedToMax: Map<TColumn, readonly RowSpanCapRejection[]>;
+    clampedRevision: number;
+}
+export declare function createRowLayoutState<TRow, TColumn extends ColumnDef = ColumnDef>(): RowLayoutState<TRow, TColumn>;
+export declare function invalidateRowLayout<TRow, TColumn extends ColumnDef>(state: RowLayoutState<TRow, TColumn>, reason: RowSpanInvalidationReason): void;
+export interface RowLayoutCell {
+    readonly kind: 'plain' | 'origin' | 'covered';
+    readonly rowSpan: number;
+    readonly colSpan: number;
+    readonly origin: SpanAddress;
+    readonly heightPx: number | null;
+    readonly widthPx: number | null;
+    readonly flexGrow: number | null;
+    readonly lastField: string | null;
+}
+export interface RowLayoutFrame {
+    readonly status: RowLayoutStatus;
+    readonly configured: boolean;
+    readonly window: RowSpanWindow;
+    readonly renderRange: RowSpanWindow;
+    readonly grid: SpanGrid | null;
+    readonly conflicts: readonly SpanConflict[];
+    readonly rowSpanLayouts: ReadonlyMap<number, RowSpanLayout<ColumnDef>>;
+    readonly colSpanLayouts: ReadonlyMap<number, ColSpanLayout>;
+    cellAt(rowIndex: number, colIndex: number): RowLayoutCell;
+    rectAt(rowIndex: number, colIndex: number): SpanRect | null;
+    navigate(from: SpanAddress, direction: SpanNavDirection): SpanAddress | null;
+    expandRange(range: SpanRange): SpanRange;
+    access(feature: SpanFeature, rowIndex: number, colIndex: number): SpanAccess | null;
+    readMatrix(range: SpanRange, mode: SpanExportMode, readValue: (origin: SpanAddress, rect: SpanRect) => unknown): SpanValueMatrix | null;
+    covers(rowIndex: number): boolean;
+    report(): SpanGridReport | null;
+}
+export declare function spanColumns<TRow, TColumn extends ColumnDef>(host: RowLayoutHostView<TRow, TColumn>): {
+    readonly rowSpan: readonly number[];
+    readonly colSpan: readonly number[];
+};
+export declare function rowLayoutStatus<TRow, TColumn extends ColumnDef>(host: RowLayoutHostView<TRow, TColumn>): RowLayoutStatus;
+export declare function buildRowLayoutFrame<TRow, TColumn extends ColumnDef>(state: RowLayoutState<TRow, TColumn>, host: RowLayoutHostView<TRow, TColumn>, window: RowSpanWindow): RowLayoutFrame;
+export interface RowSpanReport {
+    readonly status: RowLayoutStatus;
+    readonly colId: string;
+    readonly rowCount: number;
+    readonly spans: readonly {
+        readonly originIndex: number;
+        readonly span: number;
+        readonly endIndex: number;
+    }[];
+    readonly rejected: readonly RowLayoutRejection[];
+    readonly callbackCalls: number;
+    readonly cache: RowSpanCacheStats;
+    readonly maxRowSpan: number;
+}
+export declare function rowSpanReport<TRow, TColumn extends ColumnDef>(state: RowLayoutState<TRow, TColumn>, host: RowLayoutHostView<TRow, TColumn>, colId: string): RowSpanReport | null;
+export interface CellSpanInfo {
+    readonly status: RowLayoutStatus;
+    readonly rowIndex: number;
+    readonly colIndex: number;
+    readonly colId: string;
+    readonly origin: SpanAddress;
+    readonly rowSpan: number;
+    readonly colSpan: number;
+    readonly combination: SpanRect['combination'];
+    readonly covered: boolean;
+    readonly container: ColSpanContainer;
+    readonly rect: {
+        readonly heightPx: number | null;
+        readonly widthPx: number | null;
+    };
+    readonly rejected: {
+        readonly row: readonly RowLayoutRejection[];
+        readonly column: readonly ColSpanRejection[];
+    };
+}
+export declare function cellSpanInfo<TRow, TColumn extends ColumnDef>(state: RowLayoutState<TRow, TColumn>, host: RowLayoutHostView<TRow, TColumn>, rowIndex: number, colId: string): CellSpanInfo | null;
+export interface SpanInteractionReport {
+    readonly status: RowLayoutStatus;
+    readonly window: RowSpanWindow;
+    readonly renderRange: RowSpanWindow;
+    readonly report: SpanGridReport | null;
+    readonly conflicts: readonly SpanConflict[];
+    readonly exportMode: SpanExportMode;
+    readonly access: SpanAccess | null;
+}
+export declare function spanInteractionReport(frame: RowLayoutFrame, exportMode: SpanExportMode, query: {
+    readonly feature: SpanFeature;
+    readonly rowIndex: number;
+    readonly colIndex: number;
+} | null): SpanInteractionReport;
+export declare function spanConflictSignature(conflicts: readonly SpanConflict[]): string | null;
+export declare function widenedPadding<TRow, TColumn extends ColumnDef>(host: RowLayoutHostView<TRow, TColumn>, frame: RowLayoutFrame): {
+    readonly top: number;
+    readonly bottom: number;
+};
+export interface RowLayoutElementHost<TRow, TColumn extends ColumnDef = ColumnDef> {
+    effectiveColumns(): readonly TColumn[];
+    isSentinelDisplayRow(row: TRow | undefined): boolean;
+    pinSideOf(column: TColumn): 'left' | 'right' | null;
+    pinnedWidthOf(column: TColumn): number | null;
+    rowHeightForIndex(fn: (index: number, row: any) => number, index: number, row: TRow | undefined, uniform: number): number;
+    serverSideModeActive(): boolean;
+    autoHeightActive(): boolean;
+    readonly viewportState: unknown;
+    readonly infiniteCache: unknown;
+}
+export declare function rowLayoutHostView<TRow, TColumn extends ColumnDef = ColumnDef>(element: RowLayoutElementHost<TRow, TColumn>, rows: readonly TRow[], uniform: number, rowHeightFn: ((index: number, row: any) => number) | undefined | null): RowLayoutHostView<TRow, TColumn>;
+export declare function spansDeclared(columns: readonly ColumnDef[]): boolean;
+export declare function spanAwareMove(frame: RowLayoutFrame | null, from: SpanAddress | null, direction: SpanNavDirection, fallback: SpanAddress | null): SpanAddress | null;
+export declare function spanAwareCellText(frame: RowLayoutFrame | null, mode: SpanExportMode, rowIndex: number, colIndex: number, read: (rowIndex: number, colIndex: number) => unknown): unknown;
+export declare function spanInteractionFor<TRow, TColumn extends ColumnDef>(state: RowLayoutState<TRow, TColumn>, host: RowLayoutHostView<TRow, TColumn>, frame: RowLayoutFrame | null, window: RowSpanWindow, exportMode: SpanExportMode, query: {
+    readonly feature: SpanFeature;
+    readonly rowIndex: number;
+    readonly colId: string;
+} | null | undefined): SpanInteractionReport;
+export { measureRowSpanGeometry };

package/dist/types/components/grid/core/row-layout/row-span.d.ts

@@ -0,0 +1,102 @@
+export type RowSpanSectionKey = string | number | null;
+export interface RowSpanParams<TRow, TColumn = string> {
+    readonly row: TRow;
+    readonly index: number;
+    readonly column: TColumn;
+    readonly sectionKey: RowSpanSectionKey;
+}
+export type RowSpanCallback<TRow, TColumn = string> = (params: RowSpanParams<TRow, TColumn>) => number;
+export interface RowSpanEntry {
+    readonly originIndex: number;
+    readonly span: number;
+    readonly endIndex: number;
+}
+export type RowSpanRejectionReason = 'invalid-span' | 'callback-threw' | 'non-deterministic' | 'clamped-to-section' | 'clamped-to-end';
+export declare const ROW_SPAN_REJECTION_REASONS: readonly [
+    "invalid-span",
+    "callback-threw",
+    "non-deterministic",
+    "clamped-to-section",
+    "clamped-to-end"
+];
+export interface RowSpanRejection {
+    readonly reason: RowSpanRejectionReason;
+    readonly index: number;
+    readonly requested: number | null;
+    readonly applied: number;
+    readonly detail: string;
+}
+export interface RowSpanLayout<TColumn = string> {
+    readonly column: TColumn;
+    readonly rowCount: number;
+    readonly spans: readonly RowSpanEntry[];
+    readonly rejected: readonly RowSpanRejection[];
+    readonly callbackCalls: number;
+}
+export interface RowSpanResolveOptions<TRow, TColumn = string> {
+    readonly rows: readonly TRow[];
+    readonly column: TColumn;
+    readonly rowSpan: RowSpanCallback<TRow, TColumn>;
+    readonly getSectionKey?: (row: TRow, index: number) => RowSpanSectionKey;
+    readonly verifyDeterminism?: boolean;
+}
+export declare function resolveRowSpanLayout<TRow, TColumn = string>(options: RowSpanResolveOptions<TRow, TColumn>): RowSpanLayout<TColumn>;
+export declare function rowSpanEntryAt(layout: RowSpanLayout<unknown>, index: number): RowSpanEntry | null;
+export declare function rowSpanOriginAt(layout: RowSpanLayout<unknown>, index: number): number;
+export declare function isRowSpanCovered(layout: RowSpanLayout<unknown>, index: number): boolean;
+export declare function rowSpanOrigins(layout: RowSpanLayout<unknown>): readonly number[];
+export type RowSpanInvalidationReason = 'sort' | 'filter' | 'group' | 'data' | 'height' | 'columns' | 'manual';
+export declare const ROW_SPAN_INVALIDATION_REASONS: readonly [
+    "sort",
+    "filter",
+    "group",
+    "data",
+    "height",
+    "columns",
+    "manual"
+];
+interface RowSpanCacheEntry<TRow, TColumn> {
+    readonly rows: readonly TRow[];
+    readonly revision: number;
+    readonly layout: RowSpanLayout<TColumn>;
+}
+export interface RowSpanCache<TRow, TColumn = string> {
+    readonly entries: Map<TColumn, RowSpanCacheEntry<TRow, TColumn>>;
+    revision: number;
+    hits: number;
+    misses: number;
+    invalidations: number;
+    lastReason: RowSpanInvalidationReason | null;
+}
+export declare function createRowSpanCache<TRow, TColumn = string>(): RowSpanCache<TRow, TColumn>;
+export declare function invalidateRowSpans<TRow, TColumn>(cache: RowSpanCache<TRow, TColumn>, reason: RowSpanInvalidationReason, column?: TColumn): void;
+export declare function resolveCachedRowSpanLayout<TRow, TColumn = string>(cache: RowSpanCache<TRow, TColumn>, options: RowSpanResolveOptions<TRow, TColumn>): RowSpanLayout<TColumn>;
+export interface RowSpanCacheStats {
+    readonly revision: number;
+    readonly entries: number;
+    readonly hits: number;
+    readonly misses: number;
+    readonly invalidations: number;
+    readonly lastReason: RowSpanInvalidationReason | null;
+}
+export declare function rowSpanCacheStats<TRow, TColumn>(cache: RowSpanCache<TRow, TColumn>): RowSpanCacheStats;
+export interface RowSpanMetrics {
+    offsetAt(index: number): number;
+}
+export declare function createUniformRowSpanMetrics(rowHeight: number): RowSpanMetrics;
+export interface RowSpanWindow {
+    readonly startIndex: number;
+    readonly endIndex: number;
+}
+export interface RowSpanPlacement {
+    readonly originIndex: number;
+    readonly span: number;
+    readonly endIndex: number;
+    readonly top: number;
+    readonly height: number;
+    readonly startsAboveWindow: boolean;
+    readonly endsBelowWindow: boolean;
+}
+export declare function rowSpanRenderRange(layout: RowSpanLayout<unknown>, window: RowSpanWindow): RowSpanWindow;
+export declare function measureRowSpanGeometry(layout: RowSpanLayout<unknown>, window: RowSpanWindow, metrics: RowSpanMetrics): readonly RowSpanPlacement[];
+export {};