@affino/datagrid-vue-app 0.1.53 → 0.1.56

package/dist/gantt.js

@@ -1,4 +1,4 @@
-import { D as t } from "./chunks/DataGridGanttStageEntry-BrCpep-f.js";
+import { D as t } from "./chunks/DataGridGanttStageEntry-CXAJI829.js";
 import { buildDataGridTimelineRenderModels as r, normalizeDataGridGanttOptions as n, resolveDataGridTimelineRange as o } from "@affino/datagrid-gantt";
 export {
   t as DataGridGanttStage,

package/dist/index.js

@@ -1,10 +1,10 @@
 import { defineComponent as Ue, ref as x, provide as wt, computed as f, watch as h, onBeforeUnmount as Ce, h as he, mergeProps as St, nextTick as ht, unref as Le, toRef as Ee, onMounted as bt } from "vue";
 import { useDataGridRuntime as Rt, cloneDataGridFilterSnapshot as Mt } from "@affino/datagrid-vue";
 import { useDataGridAppSelection as Ot, useDataGridAppRowSelection as Ct } from "@affino/datagrid-vue/app";
-import { r as Pt, g as At, h as Dt, i as Bt, j as Ft, b as Gt, d as xt, c as jt, k as Lt, u as Et, D as It } from "./chunks/useDataGridAppRowModel-IZGtp43V.js";
-import { a as en, l as tn } from "./chunks/useDataGridAppRowModel-IZGtp43V.js";
+import { r as Pt, g as At, h as Dt, i as Bt, j as Ft, b as Gt, d as xt, c as jt, k as Lt, u as Et, D as It } from "./chunks/useDataGridAppRowModel-BNf-auAJ.js";
+import { a as en, l as tn } from "./chunks/useDataGridAppRowModel-BNf-auAJ.js";
 import { r as Tt } from "./chunks/dataGridAdvancedFilter-xnME5bRa.js";
-import { r as Kt } from "./chunks/DataGridGanttStageEntry-BrCpep-f.js";
+import { r as Kt } from "./chunks/DataGridGanttStageEntry-CXAJI829.js";
 import { applyGridTheme as Ht, resolveGridThemeTokens as Vt, defaultStyleConfig as L, sugarTheme as Ne, industrialNeutralTheme as Ie } from "@affino/datagrid-theme";
 import { d as zt } from "./chunks/dataGridOverlayThemeVars-vzY74EIz.js";
 function Vo() {

package/dist/internal.js

@@ -1,7 +1,7 @@
 import { d as t, r } from "./chunks/dataGridOverlayThemeVars-vzY74EIz.js";
 import { buildDataGridChromePaneModel as i, buildDataGridChromeRenderModel as d } from "@affino/datagrid-chrome";
-import { D as l, a as n, r as G, b as D, c as S, d as u, u as g, e as b, f as T } from "./chunks/useDataGridAppRowModel-IZGtp43V.js";
-import { _ as p, a as c, c as R, b as x, d as C, p as f, u as v, e as M, f as h, g as w, h as y, i as F, j as P, k as A, l as O, m as _, n as E, o as H } from "./chunks/DataGridGanttStageEntry-BrCpep-f.js";
+import { D as l, a as n, r as G, b as D, c as S, d as u, u as g, e as b, f as T } from "./chunks/useDataGridAppRowModel-BNf-auAJ.js";
+import { _ as p, a as c, c as R, b as x, d as C, p as f, u as v, e as M, f as h, g as w, h as y, i as F, j as P, k as A, l as O, m as _, n as E, o as H } from "./chunks/DataGridGanttStageEntry-CXAJI829.js";
 import { _ as V } from "./chunks/DataGridAdvancedFilterPopover.vue_vue_type_script_setup_true_lang-DxZakgyj.js";
 import { _ as k } from "./chunks/DataGridFindReplacePopover.vue_vue_type_script_setup_true_lang-BEVRKG31.js";
 import { buildDataGridTimelineRenderModels as B, normalizeDataGridGanttOptions as I, resolveDataGridTimelineRange as L } from "@affino/datagrid-gantt";

package/dist/perf/dataGridPerfTrace.d.ts

@@ -0,0 +1,27 @@
+export declare const DATA_GRID_PERF_STORE_KEY = "__AFFINO_DATAGRID_PERF__";
+export type DataGridPerfSample = {
+    scope: string;
+    ts: number;
+    totalMs: number;
+    [key: string]: string | number;
+};
+export type DataGridPerfSummary = {
+    scope: string;
+    count: number;
+    meanMs: number;
+    p95Ms: number;
+    maxMs: number;
+};
+export type DataGridPerfStore = {
+    samples: DataGridPerfSample[];
+    push: (sample: DataGridPerfSample) => void;
+    clear: () => void;
+    latest: (scope?: string) => DataGridPerfSample | null;
+    summary: () => DataGridPerfSummary[];
+};
+export declare function parseDataGridBooleanToken(value: string | null): boolean | null;
+export declare function resolveDataGridPerfTraceEnabled(): boolean;
+export declare function resolveDataGridPerfNow(): number;
+export declare function createDataGridPerfStore(): DataGridPerfStore;
+export declare function resolveDataGridPerfStore(): DataGridPerfStore | null;
+export declare function recordDataGridPerfSample(sample: DataGridPerfSample): void;

package/dist/stage/dataGridStageOverlayGeometry.d.ts

@@ -0,0 +1,89 @@
+import type { DataGridTableStageBodyColumn, DataGridTableStageOverlayLane, DataGridTableStageOverlaySegment } from "./dataGridTableStageBody.types";
+import type { DataGridTableStageCustomOverlay } from "./dataGridTableStage.types";
+export interface DataGridStageOverlayMetrics {
+    startRowOffset: number;
+    endRowOffset: number;
+    startColumnIndex: number;
+    endColumnIndex: number;
+    top: number;
+    height: number;
+}
+export interface DataGridStageOverlayBounds {
+    startRowOffset: number;
+    endRowOffset: number;
+    startColumnIndex: number;
+    endColumnIndex: number;
+}
+export interface DataGridStageOverlayMetricsSource {
+    top: number;
+    height: number;
+}
+export interface DataGridStageOverlayGeometryContext {
+    bodyViewportClientHeight: number;
+    indexColumnWidthPx: number;
+    leftPaneWidth: number;
+    rightPaneWidth: number;
+    renderedColumns: readonly DataGridTableStageBodyColumn[];
+    pinnedLeftColumns: readonly DataGridTableStageBodyColumn[];
+    pinnedRightColumns: readonly DataGridTableStageBodyColumn[];
+    layoutGridContentWidth: number;
+    columnIndexByKey: (columnKey: string) => number;
+    resolveColumnWidth: (column: DataGridTableStageBodyColumn) => number;
+    resolveLeftColumnSpacerWidth: () => number;
+}
+export declare function mergeOverlayBounds(left: DataGridStageOverlayBounds | null, right: DataGridStageOverlayBounds | null): DataGridStageOverlayBounds | null;
+export declare function resolveOverlayMetrics(bounds: DataGridStageOverlayBounds | null, metricsSource?: readonly DataGridStageOverlayMetricsSource[]): DataGridStageOverlayMetrics | null;
+export declare function resolveOverlayMetricsList<TRange>(ranges: readonly TRange[], resolveBounds: (range: TRange | null) => DataGridStageOverlayBounds | null, metricsSource?: readonly DataGridStageOverlayMetricsSource[]): DataGridStageOverlayMetrics[];
+export declare function buildOverlaySegment(key: string, top: number, left: number, width: number, height: number, options?: {
+    omitLeftBorder?: boolean;
+    omitRightBorder?: boolean;
+    hideBorder?: boolean;
+    borderColor?: string;
+    backgroundColor?: string;
+    borderStyle?: "solid" | "dashed";
+    zIndex?: number;
+    topBleed?: number;
+    bottomBleed?: number;
+    leftBleed?: number;
+    rightBleed?: number;
+}): DataGridTableStageOverlaySegment;
+export declare function buildPinnedPaneSeamOverlaySegment(key: string, top: number, height: number, side: "left" | "right", options?: {
+    hideBorder?: boolean;
+    seamEdge?: "left" | "right";
+    borderColor?: string;
+    backgroundColor?: string;
+    borderStyle?: "solid" | "dashed";
+    zIndex?: number;
+    topBleed?: number;
+    bottomBleed?: number;
+}): DataGridTableStageOverlaySegment;
+export declare function buildPaneOverlaySegments(context: DataGridStageOverlayGeometryContext, metrics: DataGridStageOverlayMetrics | null, pane: "left" | "center" | "right", keyPrefix: string, options?: {
+    borderColor?: string;
+    backgroundColor?: string;
+    borderStyle?: "solid" | "dashed";
+    hideSingleCell?: boolean;
+    zIndex?: number;
+}, viewportHeight?: number): DataGridTableStageOverlaySegment[];
+export declare function buildPinnedPaneSeamOverlaySegments(context: DataGridStageOverlayGeometryContext, metrics: DataGridStageOverlayMetrics | null, pane: "left" | "right", keyPrefix: string, options?: {
+    borderColor?: string;
+    backgroundColor?: string;
+    borderStyle?: "solid" | "dashed";
+    hideSingleCell?: boolean;
+    zIndex?: number;
+}, viewportHeight?: number): DataGridTableStageOverlaySegment[];
+export declare function buildPaneOverlaySegmentsForMetricsList(context: DataGridStageOverlayGeometryContext, metricsList: readonly DataGridStageOverlayMetrics[], pane: "left" | "center" | "right", keyPrefix: string, options?: {
+    borderColor?: string;
+    backgroundColor?: string;
+    borderStyle?: "solid" | "dashed";
+    hideSingleCell?: boolean;
+    zIndex?: number;
+}, viewportHeight?: number): DataGridTableStageOverlaySegment[];
+export declare function buildPinnedPaneSeamOverlaySegmentsForMetricsList(context: DataGridStageOverlayGeometryContext, metricsList: readonly DataGridStageOverlayMetrics[], pane: "left" | "right", keyPrefix: string, options?: {
+    borderColor?: string;
+    backgroundColor?: string;
+    borderStyle?: "solid" | "dashed";
+    hideSingleCell?: boolean;
+    zIndex?: number;
+}, viewportHeight?: number): DataGridTableStageOverlaySegment[];
+export declare function buildCustomOverlayLane(context: DataGridStageOverlayGeometryContext, overlay: DataGridTableStageCustomOverlay, pane: "left" | "center" | "right", metricsList: readonly DataGridStageOverlayMetrics[], viewportHeight?: number): DataGridTableStageOverlayLane | null;
+export declare function buildCustomSeamOverlayLane(context: DataGridStageOverlayGeometryContext, overlay: DataGridTableStageCustomOverlay, pane: "left" | "right", metricsList: readonly DataGridStageOverlayMetrics[], viewportHeight?: number): DataGridTableStageOverlayLane | null;

package/dist/stage/dataGridTableStageHelpers.d.ts

@@ -0,0 +1,10 @@
+import type { CSSProperties } from "vue";
+import type { DataGridTableStageBodyColumn } from "./dataGridTableStageBody.types";
+export declare function parsePixelValue(value: unknown, fallback: number): number;
+export declare function resolveColumnWidth(column: DataGridTableStageBodyColumn, resolveColumnStyle: (key: string) => CSSProperties): number;
+export declare function readPivotHeaderMeta(column: DataGridTableStageBodyColumn): {
+    groupLabels?: readonly string[];
+} | null;
+export declare function resolveTextAlign(value: unknown): CSSProperties["textAlign"] | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function hasGroupCellRenderer(column: DataGridTableStageBodyColumn): boolean;

package/dist/stage/useDataGridPerfTrace.d.ts

@@ -0,0 +1,9 @@
+import { type Ref } from "vue";
+import type { DataGridTableRow, DataGridTableStageViewportSection } from "./dataGridTableStage.types";
+export interface UseDataGridPerfTraceOptions<TRow extends Record<string, unknown>> {
+    viewport: Ref<DataGridTableStageViewportSection>;
+    displayRows: Ref<readonly DataGridTableRow<TRow>[]>;
+    bodyViewportScrollTop: Ref<number>;
+    perfTraceEnabled?: boolean;
+}
+export declare function useDataGridPerfTrace<TRow extends Record<string, unknown>>(options: UseDataGridPerfTraceOptions<TRow>): boolean;

package/dist/stage/useDataGridStageCellRendering.d.ts

@@ -0,0 +1,38 @@
+import { type Ref, type VNodeChild } from "vue";
+import type { DataGridFilterableComboboxOption } from "../overlays/dataGridFilterableCombobox";
+import type { DataGridTableMode, DataGridTableRow, DataGridTableStageEditingSection, DataGridTableStageRowsSection } from "./dataGridTableStage.types";
+import type { DataGridTableStageBodyColumn, DataGridTableStageSelectEditorOption, DataGridTableStageSelectEditorOptionsLoader } from "./dataGridTableStageBody.types";
+export interface UseDataGridStageCellRenderingOptions {
+    mode: Readonly<Ref<DataGridTableMode>>;
+    visibleColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
+    rows: Readonly<Ref<DataGridTableStageRowsSection<Record<string, unknown>>>>;
+    cells: Readonly<Ref<{
+        readCell: (row: DataGridTableRow<Record<string, unknown>>, columnKey: string) => string;
+        readDisplayCell: (row: DataGridTableRow<Record<string, unknown>>, columnKey: string) => string;
+    }>>;
+    editing: Readonly<Ref<DataGridTableStageEditingSection<Record<string, unknown>>>>;
+    isCellEditableSafe: (row: DataGridTableRow<Record<string, unknown>>, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
+    isEditingCellSafe: (row: DataGridTableRow<Record<string, unknown>>, columnKey: string) => boolean;
+    columnIndexByKey: (columnKey: string) => number;
+}
+export interface UseDataGridStageCellRenderingResult {
+    startInlineEditIfAllowed: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn, rowOffset: number) => void;
+    resolveCellEditorMode: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn) => "none" | "text" | "select" | "date" | "datetime";
+    resolveSelectEditorOptions: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn) => readonly DataGridTableStageSelectEditorOption[];
+    resolveSelectEditorOptionsLoader: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn) => DataGridTableStageSelectEditorOptionsLoader | undefined;
+    handleSelectEditorOptionsResolved: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn, options: ReadonlyArray<DataGridFilterableComboboxOption>) => void;
+    readResolvedDisplayCell: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn) => string;
+    renderResolvedCellContent: (row: DataGridTableRow<Record<string, unknown>>, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => VNodeChild;
+    resolveSelectEditorValue: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn) => string;
+    isSelectEditorCell: (row: DataGridTableRow<Record<string, unknown>>, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
+    isDateEditorCell: (row: DataGridTableRow<Record<string, unknown>>, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
+    resolveDateEditorInputType: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn) => "date" | "datetime-local";
+    isTextEditorCell: (row: DataGridTableRow<Record<string, unknown>>, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
+    handleSelectEditorCommit: (value: string, target?: "stay" | "next" | "previous") => void;
+    handleSelectEditorCancel: () => void;
+    handleDateEditorChange: (value: string, target?: "stay" | "next" | "previous") => void;
+    handleTextEditorBlur: () => void;
+    updateEditingCellValue: (value: string) => void;
+    handleEditorKeydown: (event: KeyboardEvent) => void;
+}
+export declare function useDataGridStageCellRendering(options: UseDataGridStageCellRenderingOptions): UseDataGridStageCellRenderingResult;

package/dist/stage/useDataGridStageCellState.d.ts

@@ -0,0 +1,31 @@
+import { type Ref } from "vue";
+import type { DataGridTableStageBodyColumn, DataGridTableStageBodyRow } from "./dataGridTableStageBody.types";
+export interface UseDataGridStageCellStateOptions {
+    visibleColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
+    cells: Readonly<Ref<{
+        readCell: (row: DataGridTableStageBodyRow, columnKey: string) => string;
+    }>>;
+    isCellEditableSafe: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
+    isEditingCellSafe: (row: DataGridTableStageBodyRow, columnKey: string) => boolean;
+    resolveCellEditorMode: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => "none" | "text" | "select" | "date" | "datetime";
+    isVisualSelectionAnchorCell: (rowOffset: number, columnIndex: number) => boolean;
+    shouldHighlightSelectedCellVisual: (rowOffset: number, columnIndex: number) => boolean;
+    isRangeMoveHandleHoverCell: (rowOffset: number, columnIndex: number) => boolean;
+    isCellInFillPreviewSafe: (rowOffset: number, columnIndex: number) => boolean;
+    isCellInPendingClipboardRangeSafe: (rowOffset: number, columnIndex: number) => boolean;
+    isCellOnPendingClipboardEdgeSafe: (rowOffset: number, columnIndex: number, edge: "top" | "right" | "bottom" | "left") => boolean;
+}
+export interface UseDataGridStageCellStateResult {
+    builtInCellClasses: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => Record<string, boolean>;
+    cellStateClasses: (row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => Record<string, boolean>;
+    cellAriaRole: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => string | undefined;
+    cellAriaChecked: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => "true" | "false" | "mixed" | undefined;
+    cellAriaPressed: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => "true" | "false" | "mixed" | undefined;
+    cellAriaLabel: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => string | undefined;
+    cellAriaDisabled: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => "true" | undefined;
+    isRowSelectionColumn: (column: DataGridTableStageBodyColumn) => boolean;
+    shouldRenderCheckboxCell: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => boolean;
+    checkboxIndicatorClass: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => Record<string, boolean>;
+    checkboxIndicatorMarkClass: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => Record<string, boolean>;
+}
+export declare function useDataGridStageCellState(options: UseDataGridStageCellStateOptions): UseDataGridStageCellStateResult;

package/dist/stage/useDataGridStageChromeCanvas.d.ts

@@ -0,0 +1,41 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { DataGridChromeRenderModel } from "@affino/datagrid-chrome";
+type GridChromeRedrawMode = "full" | "center-scroll";
+export interface UseDataGridStageChromeCanvasOptions {
+    stageRootEl: Ref<HTMLElement | null>;
+    bodyShellRef: Ref<HTMLElement | null>;
+    bodyViewportEl: Ref<HTMLElement | null>;
+    bottomViewportEl: Ref<HTMLElement | null>;
+    leftHeaderChromeCanvasEl: Ref<HTMLCanvasElement | null>;
+    centerHeaderChromeCanvasEl: Ref<HTMLCanvasElement | null>;
+    rightHeaderChromeCanvasEl: Ref<HTMLCanvasElement | null>;
+    leftChromeCanvasEl: Ref<HTMLCanvasElement | null>;
+    centerChromeCanvasEl: Ref<HTMLCanvasElement | null>;
+    rightChromeCanvasEl: Ref<HTMLCanvasElement | null>;
+    leftBottomChromeCanvasEl: Ref<HTMLCanvasElement | null>;
+    centerBottomChromeCanvasEl: Ref<HTMLCanvasElement | null>;
+    rightBottomChromeCanvasEl: Ref<HTMLCanvasElement | null>;
+    bodyViewportScrollTop: Ref<number>;
+    bodyViewportScrollLeft: Ref<number>;
+    bodyViewportClientWidth: Ref<number>;
+    bodyViewportClientHeight: Ref<number>;
+    pinnedBottomViewportClientHeight: Ref<number>;
+    bodyViewportTopOffset: Ref<number>;
+    headerShellHeight: Ref<number>;
+    headerViewportClientWidth: Ref<number>;
+    chromeRenderModel: ComputedRef<DataGridChromeRenderModel>;
+    headerChromeRenderModel: ComputedRef<DataGridChromeRenderModel>;
+    pinnedBottomChromeRenderModel: ComputedRef<DataGridChromeRenderModel>;
+    hasPivotHeaderGroups: ComputedRef<boolean>;
+}
+export interface UseDataGridStageChromeCanvasResult {
+    syncBodyViewportMetrics: () => void;
+    syncPinnedBottomViewportMetrics: () => void;
+    syncPinnedBottomViewportScrollLeft: () => void;
+    scheduleGridChromeRedraw: (mode?: GridChromeRedrawMode) => void;
+    flushGridChromeRedraw: (mode?: GridChromeRedrawMode) => void;
+    connectGridChromeResizeObserver: () => void;
+    disconnectGridChromeResizeObserver: () => void;
+}
+export declare function useDataGridStageChromeCanvas(options: UseDataGridStageChromeCanvasOptions): UseDataGridStageChromeCanvasResult;
+export {};

package/dist/stage/useDataGridStageChromeModel.d.ts

@@ -0,0 +1,73 @@
+import { type ComputedRef, type Ref } from "vue";
+import { type DataGridChromeRenderModel } from "@affino/datagrid-chrome";
+import type { DataGridTableStageBodyColumn, DataGridTableStageBodyRow } from "./dataGridTableStageBody.types";
+import type { DataGridTableStageLayoutSection, DataGridTableStageRowsSection, DataGridTableStageViewportSection } from "./dataGridTableStage.types";
+interface DataGridPivotHeaderMeta {
+    groupLabels?: readonly string[];
+}
+export interface UseDataGridStageChromeModelOptions {
+    mode: Ref<string>;
+    rowHeightMode: Ref<string>;
+    layout: Ref<DataGridTableStageLayoutSection>;
+    viewport: Ref<DataGridTableStageViewportSection>;
+    rows: Ref<DataGridTableStageRowsSection<Record<string, unknown>>>;
+    visibleColumns: Ref<readonly DataGridTableStageBodyColumn[]>;
+    renderedColumns: Ref<readonly DataGridTableStageBodyColumn[]>;
+    displayRows: Ref<readonly DataGridTableStageBodyRow[]>;
+    pinnedBottomRows: Ref<readonly DataGridTableStageBodyRow[]>;
+    selectionTotalRowCount: Ref<number | null | undefined>;
+    leftPaneWidth: Ref<number>;
+    rightPaneWidth: Ref<number>;
+    bodyViewportScrollTop: Ref<number>;
+    bodyViewportScrollLeft: Ref<number>;
+    bodyViewportClientWidth: Ref<number>;
+    bodyViewportClientHeight: Ref<number>;
+    pinnedBottomViewportClientHeight: Ref<number>;
+    headerShellHeight: Ref<number>;
+    headerViewportClientWidth: Ref<number>;
+    bodyViewportEl: Ref<HTMLElement | null>;
+    indexColumnWidthPx: Ref<number>;
+    pinnedLeftColumns: Ref<readonly DataGridTableStageBodyColumn[]>;
+    pinnedRightColumns: Ref<readonly DataGridTableStageBodyColumn[]>;
+    resolveColumnWidth: (column: DataGridTableStageBodyColumn) => number;
+    resolveLeftColumnSpacerWidth: () => number;
+    resolveRightColumnSpacerWidth: () => number;
+    resolveAbsoluteRowIndex: (row: DataGridTableStageBodyRow, rowOffset: number) => number;
+    resolveViewportRowOffset: (row: DataGridTableStageBodyRow, rowOffset: number) => number;
+    isHoveredRow: (row: DataGridTableStageBodyRow, rowOffset: number) => boolean;
+    isStripedRow: (row: DataGridTableStageBodyRow, rowOffset: number) => boolean;
+    readPivotHeaderMeta: (column: DataGridTableStageBodyColumn) => DataGridPivotHeaderMeta | null;
+}
+export interface UseDataGridStageChromeModelResult {
+    chromeRenderModel: ComputedRef<DataGridChromeRenderModel>;
+    headerChromeRenderModel: ComputedRef<DataGridChromeRenderModel>;
+    pinnedBottomChromeRenderModel: ComputedRef<DataGridChromeRenderModel>;
+    hasPivotHeaderGroups: ComputedRef<boolean>;
+    rowMetrics: ComputedRef<readonly {
+        top: number;
+        height: number;
+    }[]>;
+    pinnedBottomRowMetrics: ComputedRef<readonly {
+        top: number;
+        height: number;
+    }[]>;
+    chromeColumnsRevision: Ref<number>;
+    chromeRowsRevision: Ref<number>;
+    rowMetricsSignature: ComputedRef<string>;
+    pinnedBottomRowMetricsSignature: ComputedRef<string>;
+    rowBandsSignature: ComputedRef<string>;
+    pinnedBottomRowBandsSignature: ComputedRef<string>;
+    leftChromeColumnsSignature: ComputedRef<string>;
+    centerChromeColumnsSignature: ComputedRef<string>;
+    rightChromeColumnsSignature: ComputedRef<string>;
+    headerPivotGroupsSignature: ComputedRef<string>;
+    resolveVisibleRowMetricsFromDom: (fallbackMetrics: readonly {
+        top: number;
+        height: number;
+    }[]) => readonly {
+        top: number;
+        height: number;
+    }[];
+}
+export declare function useDataGridStageChromeModel(options: UseDataGridStageChromeModelOptions): UseDataGridStageChromeModelResult;
+export {};

package/dist/stage/useDataGridStageFillAction.d.ts

@@ -0,0 +1,51 @@
+import { type CSSProperties, type Ref } from "vue";
+import type { DataGridOverlayRange } from "@affino/datagrid-vue";
+import type { DataGridTableStageBodyColumn, DataGridTableStageBodyRow } from "./dataGridTableStageBody.types";
+export interface UseDataGridStageFillActionOptions {
+    selection: Readonly<Ref<{
+        fillActionAnchorCell?: {
+            rowIndex: number;
+            columnIndex: number;
+        } | null;
+        fillPreviewRange: DataGridOverlayRange | null;
+        isFillDragging: boolean;
+    } | null>>;
+    selectionRange: Readonly<Ref<DataGridOverlayRange | null>>;
+    visibleColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
+    renderedColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
+    displayRows: Readonly<Ref<readonly DataGridTableStageBodyRow[]>>;
+    bodyViewportEl: Readonly<Ref<HTMLElement | null>>;
+    bodyShellRef: Readonly<Ref<HTMLElement | null>>;
+    bodyViewportClientHeight: Readonly<Ref<number>>;
+    bodyViewportTopOffset: Readonly<Ref<number>>;
+    bodyViewportScrollLeft: Readonly<Ref<number>>;
+    leftPaneWidth: Readonly<Ref<number>>;
+    rightPaneWidth: Readonly<Ref<number>>;
+    effectiveBodyViewportWidth: Readonly<Ref<number>>;
+    indexColumnWidthPx: Readonly<Ref<number>>;
+    pinnedLeftColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
+    pinnedRightColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
+    resolveColumnWidth: (column: DataGridTableStageBodyColumn) => number;
+    resolveViewportRowStart: () => number;
+    resolveVisibleCellElement: (rowIndex: number, columnIndex: number) => HTMLElement | null;
+    resolveVisibleRowElement: (rowIndex: number) => HTMLElement | null;
+    resolveRelativeCellRect: (anchorCell: {
+        rowIndex: number;
+        columnIndex: number;
+    }) => {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    } | null;
+    isVisibleCellEditableByAbsoluteCoord: (rowIndex: number, columnIndex: number) => boolean;
+    restoreAnchorCellFocus: () => void;
+}
+export interface UseDataGridStageFillActionResult {
+    fillActionMenuOpen: Ref<boolean>;
+    floatingFillActionStyle: Readonly<Ref<CSSProperties | null>>;
+    focusFillActionAnchorCell: () => void;
+    toggleFloatingFillActionMenu: (event: MouseEvent) => void;
+    handleFillActionSelection: () => void;
+}
+export declare function useDataGridStageFillAction(options: UseDataGridStageFillActionOptions): UseDataGridStageFillActionResult;

package/dist/stage/useDataGridStageFocusRuntime.d.ts

@@ -0,0 +1,33 @@
+import type { Ref } from "vue";
+import type { DataGridTableStageBodyColumn, DataGridTableStageBodyRow } from "./dataGridTableStageBody.types";
+export interface UseDataGridStageFocusRuntimeOptions {
+    bodyShellRef: Readonly<Ref<HTMLElement | null>>;
+    bodyViewportEl: Readonly<Ref<HTMLElement | null>>;
+    leftPaneContentRef: Readonly<Ref<HTMLElement | null>>;
+    rightPaneContentRef: Readonly<Ref<HTMLElement | null>>;
+    leftBottomPaneContentRef: Readonly<Ref<HTMLElement | null>>;
+    rightBottomPaneContentRef: Readonly<Ref<HTMLElement | null>>;
+    displayRows: Readonly<Ref<readonly DataGridTableStageBodyRow[]>>;
+    visibleColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
+    viewportRowStart: Readonly<Ref<number>>;
+    resolveAbsoluteRowIndex: (row: DataGridTableStageBodyRow, rowOffset: number) => number;
+    isSelectionAnchorCellSafe: (rowOffset: number, columnIndex: number) => boolean;
+    isCellEditableSafe: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
+}
+export interface UseDataGridStageFocusRuntimeResult {
+    isVisibleCellEditableByAbsoluteCoord: (rowIndex: number, columnIndex: number) => boolean;
+    resolveVisibleCellElement: (rowIndex: number, columnIndex: number) => HTMLElement | null;
+    resolveVisibleRowElement: (rowIndex: number) => HTMLElement | null;
+    resolveRelativeCellRect: (cell: {
+        rowIndex: number;
+        columnIndex: number;
+    } | null) => {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    } | null;
+    focusVisibleAnchorCell: () => void;
+    restoreAnchorCellFocus: () => void;
+}
+export declare function useDataGridStageFocusRuntime(options: UseDataGridStageFocusRuntimeOptions): UseDataGridStageFocusRuntimeResult;

package/dist/stage/useDataGridStageOverlays.d.ts

@@ -0,0 +1,70 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { DataGridOverlayRange } from "@affino/datagrid-vue";
+import type { DataGridTableStageBodyColumn, DataGridTableStageOverlayLane, DataGridTableStageOverlaySegment } from "./dataGridTableStageBody.types";
+import type { DataGridTableStageCustomOverlay } from "./dataGridTableStage.types";
+import { type DataGridStageOverlayBounds, type DataGridStageOverlayGeometryContext, type DataGridStageOverlayMetricsSource } from "./dataGridStageOverlayGeometry";
+export interface UseDataGridStageOverlaysOptions {
+    overlayGeometryContext: ComputedRef<DataGridStageOverlayGeometryContext>;
+    bodyViewportClientHeight: Ref<number>;
+    bodyViewportScrollTop: Ref<number>;
+    bottomViewportClientHeight: Ref<number>;
+    visibleColumns: ComputedRef<readonly DataGridTableStageBodyColumn[]>;
+    displayRows: ComputedRef<readonly unknown[]>;
+    selectionRanges: ComputedRef<readonly DataGridOverlayRange[]>;
+    selectionRange: ComputedRef<DataGridOverlayRange | null>;
+    fillPreviewRange: ComputedRef<DataGridOverlayRange | null>;
+    rangeMovePreviewRange: ComputedRef<DataGridOverlayRange | null>;
+    rowMetrics: ComputedRef<readonly DataGridStageOverlayMetricsSource[]>;
+    pinnedBottomRowMetrics: ComputedRef<readonly DataGridStageOverlayMetricsSource[]>;
+    isCellSelectedSafe: (rowOffset: number, columnIndex: number) => boolean;
+    isCellInFillPreviewSafe: (rowOffset: number, columnIndex: number) => boolean;
+    isAdditiveSelection: ComputedRef<boolean>;
+    isFillDragging: ComputedRef<boolean>;
+    isRangeMoving: ComputedRef<boolean>;
+    resolveVisibleRangeBounds: (range: DataGridOverlayRange | null) => DataGridStageOverlayBounds | null;
+    resolvePinnedBottomVisibleRangeBounds: (range: DataGridOverlayRange | null) => DataGridStageOverlayBounds | null;
+    customOverlays: ComputedRef<readonly DataGridTableStageCustomOverlay[]>;
+}
+export interface UseDataGridStageOverlaysResult {
+    leftSelectionOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftSelectionSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    centerSelectionOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightSelectionOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightSelectionSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftPinnedBottomSelectionOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftPinnedBottomSelectionSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    centerPinnedBottomSelectionOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightPinnedBottomSelectionOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightPinnedBottomSelectionSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftFillPreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftFillPreviewSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    centerFillPreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightFillPreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightFillPreviewSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftPinnedBottomFillPreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftPinnedBottomFillPreviewSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    centerPinnedBottomFillPreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightPinnedBottomFillPreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightPinnedBottomFillPreviewSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftMovePreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftMovePreviewSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    centerMovePreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightMovePreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightMovePreviewSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftPinnedBottomMovePreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftPinnedBottomMovePreviewSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    centerPinnedBottomMovePreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightPinnedBottomMovePreviewOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    rightPinnedBottomMovePreviewSeamOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;
+    leftCustomOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+    centerCustomOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+    rightCustomOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+    leftCustomSeamOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+    rightCustomSeamOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+    leftPinnedBottomCustomOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+    centerPinnedBottomCustomOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+    rightPinnedBottomCustomOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+    leftPinnedBottomCustomSeamOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+    rightPinnedBottomCustomSeamOverlayLanes: ComputedRef<readonly DataGridTableStageOverlayLane[]>;
+}
+export declare function useDataGridStageOverlays(options: UseDataGridStageOverlaysOptions): UseDataGridStageOverlaysResult;

package/dist/stage/useDataGridStagePanes.d.ts

@@ -0,0 +1,76 @@
+import { type CSSProperties, type ComputedRef, type Ref } from "vue";
+import type { DataGridTableStageBodyColumn, DataGridTableStageBodyRow } from "./dataGridTableStageBody.types";
+import type { DataGridTableStageOverlayLane, DataGridTableStageOverlaySegment, DataGridTableStagePinnedPaneProps } from "./dataGridTableStageBody.types";
+export interface UseDataGridStagePanesOptions {
+    leftPaneWidth: Readonly<Ref<number>>;
+    rightPaneWidth: Readonly<Ref<number>>;
+    leftPaneContentRef: Ref<HTMLElement | null>;
+    rightPaneContentRef: Ref<HTMLElement | null>;
+    leftBottomPaneContentRef: Ref<HTMLElement | null>;
+    rightBottomPaneContentRef: Ref<HTMLElement | null>;
+    displayRows: Readonly<Ref<readonly DataGridTableStageBodyRow[]>>;
+    pinnedBottomRows: Readonly<Ref<readonly DataGridTableStageBodyRow[]>>;
+    showRowIndex: Readonly<Ref<boolean>>;
+    pinnedLeftColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
+    pinnedRightColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
+    leftSelectionOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftSelectionSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    centerSelectionOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightSelectionOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightSelectionSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftPinnedBottomSelectionOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftPinnedBottomSelectionSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    centerPinnedBottomSelectionOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightPinnedBottomSelectionOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightPinnedBottomSelectionSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftFillPreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftFillPreviewSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    centerFillPreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightFillPreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightFillPreviewSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftPinnedBottomFillPreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftPinnedBottomFillPreviewSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    centerPinnedBottomFillPreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightPinnedBottomFillPreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightPinnedBottomFillPreviewSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftMovePreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftMovePreviewSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    centerMovePreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightMovePreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightMovePreviewSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftPinnedBottomMovePreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftPinnedBottomMovePreviewSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    centerPinnedBottomMovePreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightPinnedBottomMovePreviewOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    rightPinnedBottomMovePreviewSeamOverlaySegments: Readonly<Ref<readonly DataGridTableStageOverlaySegment[]>>;
+    leftCustomOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    centerCustomOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    rightCustomOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    leftCustomSeamOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    rightCustomSeamOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    leftPinnedBottomCustomOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    centerPinnedBottomCustomOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    rightPinnedBottomCustomOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    leftPinnedBottomCustomSeamOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    rightPinnedBottomCustomSeamOverlayLanes: Readonly<Ref<readonly DataGridTableStageOverlayLane[]>>;
+    bodyViewportClientWidth: Readonly<Ref<number>>;
+    bodyViewportClientHeight: Readonly<Ref<number>>;
+    pinnedBottomViewportClientHeight: Readonly<Ref<number>>;
+    headerShellHeight: Readonly<Ref<number>>;
+    headerViewportClientWidth: Readonly<Ref<number>>;
+}
+export interface UseDataGridStagePanesResult {
+    paneLayoutStyle: ComputedRef<CSSProperties>;
+    leftPaneStyle: ComputedRef<CSSProperties>;
+    rightPaneStyle: ComputedRef<CSSProperties>;
+    leftTrackStyle: ComputedRef<CSSProperties>;
+    rightTrackStyle: ComputedRef<CSSProperties>;
+    centerHeaderChromeCanvasStyle: ComputedRef<CSSProperties>;
+    centerChromeCanvasStyle: ComputedRef<CSSProperties>;
+    centerBottomChromeCanvasStyle: ComputedRef<CSSProperties>;
+    leftPinnedPane: ComputedRef<DataGridTableStagePinnedPaneProps>;
+    rightPinnedPane: ComputedRef<DataGridTableStagePinnedPaneProps>;
+    leftPinnedBottomPane: ComputedRef<DataGridTableStagePinnedPaneProps>;
+    rightPinnedBottomPane: ComputedRef<DataGridTableStagePinnedPaneProps>;
+}
+export declare function useDataGridStagePanes(options: UseDataGridStagePanesOptions): UseDataGridStagePanesResult;