@affino/datagrid-vue-app 0.1.62 → 0.1.64

package/dist/internal.js

@@ -1,8 +1,8 @@
 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-B8E788Tu.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-B-Igcclh.js";
-import { _ as V } from "./chunks/DataGridAdvancedFilterPopover.vue_vue_type_script_setup_true_lang-DxZakgyj.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-DF6K2Rd8.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-DGDFifU8.js";
+import { _ as V } from "./chunks/DataGridAdvancedFilterPopover.vue_vue_type_script_setup_true_lang-AVmOe3Bv.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";
 export {

package/dist/overlays/DataGridCellComboboxEditor.vue.d.ts

@@ -7,6 +7,7 @@ type __VLS_Props = {
     placeholder?: string;
     initialFilter?: string;
     openOnMount?: boolean;
+    disabled?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     commit: (value: string, target?: CommitTarget | undefined) => void;

package/dist/perf/dataGridPerfTrace.d.ts

@@ -5,6 +5,12 @@ export type DataGridPerfSample = {
     totalMs: number;
     [key: string]: string | number;
 };
+export type DataGridPerfSampleInput = {
+    scope: string;
+    totalMs: number;
+    ts?: number;
+    [key: string]: string | number | undefined;
+};
 export type DataGridPerfSummary = {
     scope: string;
     count: number;
@@ -25,3 +31,4 @@ export declare function resolveDataGridPerfNow(): number;
 export declare function createDataGridPerfStore(): DataGridPerfStore;
 export declare function resolveDataGridPerfStore(): DataGridPerfStore | null;
 export declare function recordDataGridPerfSample(sample: DataGridPerfSample): void;
+export declare function recordDataGridPerfSampleIfEnabled(sample: DataGridPerfSampleInput): void;

package/dist/stage/DataGridTableStageCenterPane.vue.d.ts

@@ -74,6 +74,10 @@ declare const __VLS_export: import("vue").DefineComponent<{
         type: PropType<((layer: string, value: string) => void) | undefined>;
         default: undefined;
     };
+    perfTraceEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     renderApi: {
         type: PropType<DataGridTableStageCenterPaneRenderApi>;
         required: true;
@@ -151,6 +155,10 @@ declare const __VLS_export: import("vue").DefineComponent<{
         type: PropType<((layer: string, value: string) => void) | undefined>;
         default: undefined;
     };
+    perfTraceEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     renderApi: {
         type: PropType<DataGridTableStageCenterPaneRenderApi>;
         required: true;
@@ -170,6 +178,7 @@ declare const __VLS_export: import("vue").DefineComponent<{
     handleWheel: (event: WheelEvent) => void;
     handleContextMenu: (event: MouseEvent) => void;
     overlayLanes: readonly DataGridTableStageOverlayLane[];
+    perfTraceEnabled: boolean;
 }, {}>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/stage/DataGridTableStageHeader.vue.d.ts

@@ -36,6 +36,10 @@ declare const __VLS_base: import("vue").DefineComponent<{
         type: BooleanConstructor;
         required: true;
     };
+    isCoarsePointer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     onLinkedViewportWheel: {
         type: PropType<(event: WheelEvent) => void>;
         required: true;
@@ -69,11 +73,17 @@ declare const __VLS_base: import("vue").DefineComponent<{
         type: BooleanConstructor;
         required: true;
     };
+    isCoarsePointer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     onLinkedViewportWheel: {
         type: PropType<(event: WheelEvent) => void>;
         required: true;
     };
-}>>, {}, {}>;
+}>>, {
+    isCoarsePointer: boolean;
+}, {}>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/stage/DataGridTableStagePinnedPane.vue.d.ts

@@ -1,4 +1,4 @@
-import type { PropType } from "vue";
+import { type PropType } from "vue";
 import type { DataGridTableStagePinnedPaneProps, DataGridTableStagePinnedPaneRenderApi } from "./dataGridTableStageBody.types";
 declare var __VLS_1: {};
 type __VLS_Slots = {} & {
@@ -17,6 +17,10 @@ declare const __VLS_base: import("vue").DefineComponent<{
         type: PropType<(event: MouseEvent) => void>;
         default: undefined;
     };
+    perfTraceEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     pane: {
         type: PropType<DataGridTableStagePinnedPaneProps>;
@@ -30,8 +34,13 @@ declare const __VLS_base: import("vue").DefineComponent<{
         type: PropType<(event: MouseEvent) => void>;
         default: undefined;
     };
+    perfTraceEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>>, {
     handleContextMenu: (event: MouseEvent) => void;
+    perfTraceEnabled: boolean;
 }, {}>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/stage/dataGridMouseEventGuards.d.ts

@@ -0,0 +1,17 @@
+export type DataGridInteractionMode = "desktop" | "touch" | "auto";
+export interface DataGridInteractionModeInput {
+    interactionMode?: DataGridInteractionMode;
+    isCoarsePointer?: boolean;
+}
+export interface DataGridMouseEventPolicy {
+    interactionMode: Exclude<DataGridInteractionMode, "auto">;
+    touchGenerated: boolean;
+    nativeScrollPriority: boolean;
+    preventDefaultAllowed: boolean;
+}
+export declare function isTouchGeneratedMouseEvent(event: MouseEvent): boolean;
+export declare function resolveDataGridInteractionMode(input?: DataGridInteractionModeInput): Exclude<DataGridInteractionMode, "auto">;
+export declare function shouldPrioritizeNativeScrollForMouseDown(event: MouseEvent, input?: DataGridInteractionModeInput): boolean;
+export declare function shouldPrioritizeNativeScrollForMouseEvent(event: MouseEvent, input?: DataGridInteractionModeInput): boolean;
+export declare function resolveDataGridMouseEventPolicy(event: MouseEvent, input?: DataGridInteractionModeInput): DataGridMouseEventPolicy;
+export declare function shouldAllowGridPreventDefaultForMouseEvent(event: MouseEvent, input?: DataGridInteractionModeInput): boolean;

package/dist/stage/dataGridTableStage.types.d.ts

@@ -158,6 +158,9 @@ export interface DataGridTableStageEditingSection<TRow extends Record<string, un
     editingCellValue: string;
     editingCellInitialFilter: string;
     editingCellOpenOnMount: boolean;
+    editingCellValidationMessage: string | null;
+    editingCellPending: boolean;
+    editingCellRejectedReason: string | null;
     isEditingCell: (row: DataGridTableRow<TRow>, columnKey: string) => boolean;
     startInlineEdit: (row: DataGridTableRow<TRow>, columnKey: string, options?: {
         draftValue?: string;
@@ -216,7 +219,7 @@ interface DataGridTableStageBindingsSource<TRow extends Record<string, unknown>>
 }
 export interface UseDataGridTableStageBindingsOptions<TRow extends Record<string, unknown>> extends Omit<{
     [K in keyof DataGridTableStageBindingsSource<TRow>]: DataGridMaybeRef<DataGridTableStageBindingsSource<TRow>[K]>;
-}, "editingCellValue" | "headerViewportRef" | "bodyViewportRef" | "updateEditingCellValue"> {
+}, "editingCellValue" | "headerViewportRef" | "bodyViewportRef"> {
     editingCellValueRef: Ref<string>;
     headerViewportRef: Ref<HTMLElement | null>;
     bodyViewportRef: Ref<HTMLElement | null>;

package/dist/stage/dataGridTableStageBody.types.d.ts

@@ -49,6 +49,7 @@ export interface DataGridTableStageBodyRenderApiBase {
     resolveCellCustomStyle: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => CSSProperties;
     columnIndexByKey: (columnKey: string) => number;
     cellTabIndex: (rowOffset: number, columnIndex: number) => number;
+    cellAriaSelected: (rowOffset: number, columnIndex: number) => "true" | "false";
     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;
@@ -59,12 +60,25 @@ export interface DataGridTableStageBodyRenderApiBase {
     handleCellMouseMove: (event: MouseEvent, rowOffset: number, columnIndex: number) => void;
     clearRangeMoveHandleHover: () => void;
     handleCellKeydown: (event: KeyboardEvent, row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => void;
-    startInlineEditIfAllowed: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number) => void;
+    startInlineEditIfAllowed: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number, event?: MouseEvent) => void;
+    handleTouchSelectionHandleMouseDown: (event: MouseEvent) => void;
+    handleTouchSelectionHandleTouchStart: (event: TouchEvent, row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => void;
+    handleTouchSelectionHandleTouchMove: (event: TouchEvent) => void;
+    handleTouchSelectionHandleTouchEnd: (event: TouchEvent) => void;
+    handleTouchRangeMoveHandleMouseDown: (event: MouseEvent) => void;
+    handleTouchRangeMoveHandleTouchStart: (event: TouchEvent, row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => void;
+    handleTouchRangeMoveHandleTouchMove: (event: TouchEvent) => void;
+    handleTouchRangeMoveHandleTouchEnd: (event: TouchEvent) => void;
     isCellEditableSafe: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
     isFillHandleCellSafe: (rowOffset: number, columnIndex: number) => boolean;
+    isTouchSelectionAnchorHandleCell: (row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => boolean;
+    isTouchRangeMoveHandleCell: (row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => boolean;
     isEditingCellSafe: (row: DataGridTableStageBodyRow, columnKey: string) => boolean;
     handleFillHandleMouseDown: (event: MouseEvent) => void;
     handleFillHandleDoubleClick: (event: MouseEvent) => void;
+    handleFillHandleTouchStart: (event: TouchEvent) => void;
+    handleFillHandleTouchMove: (event: TouchEvent) => void;
+    handleFillHandleTouchEnd: (event: TouchEvent) => void;
     isSelectEditorCell: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
     resolveSelectEditorValue: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => string;
     resolveSelectEditorOptions: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => readonly DataGridTableStageSelectEditorOption[];

package/dist/stage/useDataGridStageCellRendering.d.ts

@@ -14,9 +14,12 @@ export interface UseDataGridStageCellRenderingOptions {
     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;
+    suppressInlineEditStart?: Readonly<Ref<boolean>>;
+    preferLightweightCellRendering?: Readonly<Ref<boolean>>;
+    perfTraceEnabled?: boolean;
 }
 export interface UseDataGridStageCellRenderingResult {
-    startInlineEditIfAllowed: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn, rowOffset: number) => void;
+    startInlineEditIfAllowed: (row: DataGridTableRow<Record<string, unknown>>, column: DataGridTableStageBodyColumn, rowOffset: number, event?: MouseEvent) => 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;

package/dist/stage/useDataGridStageCellState.d.ts

@@ -8,6 +8,7 @@ export interface UseDataGridStageCellStateOptions {
     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";
+    isCellSelectedSafe: (rowOffset: number, columnIndex: number) => boolean;
     isVisualSelectionAnchorCell: (rowOffset: number, columnIndex: number) => boolean;
     shouldHighlightSelectedCellVisual: (rowOffset: number, columnIndex: number) => boolean;
     isRangeMoveHandleHoverCell: (rowOffset: number, columnIndex: number) => boolean;
@@ -18,6 +19,7 @@ export interface UseDataGridStageCellStateOptions {
 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>;
+    cellAriaSelected: (rowOffset: number, columnIndex: number) => "true" | "false";
     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;

package/dist/stage/useDataGridStageChromeCanvas.d.ts

@@ -27,6 +27,7 @@ export interface UseDataGridStageChromeCanvasOptions {
     headerChromeRenderModel: ComputedRef<DataGridChromeRenderModel>;
     pinnedBottomChromeRenderModel: ComputedRef<DataGridChromeRenderModel>;
     hasPivotHeaderGroups: ComputedRef<boolean>;
+    perfTraceEnabled?: boolean;
 }
 export interface UseDataGridStageChromeCanvasResult {
     syncBodyViewportMetrics: () => void;

package/dist/stage/useDataGridStageFocusRuntime.d.ts

@@ -13,6 +13,9 @@ export interface UseDataGridStageFocusRuntimeOptions {
     resolveAbsoluteRowIndex: (row: DataGridTableStageBodyRow, rowOffset: number) => number;
     isSelectionAnchorCellSafe: (rowOffset: number, columnIndex: number) => boolean;
     isCellEditableSafe: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
+    isBodyViewportScrolling?: Readonly<Ref<boolean>>;
+    runWhenBodyViewportScrollIdle?: (callback: () => void) => void;
+    shouldRestoreAnchorFocus?: () => boolean;
 }
 export interface UseDataGridStageFocusRuntimeResult {
     isVisibleCellEditableByAbsoluteCoord: (rowIndex: number, columnIndex: number) => boolean;

package/dist/stage/useDataGridStageOverlays.d.ts

@@ -24,6 +24,7 @@ export interface UseDataGridStageOverlaysOptions {
     resolveVisibleRangeBounds: (range: DataGridOverlayRange | null) => DataGridStageOverlayBounds | null;
     resolvePinnedBottomVisibleRangeBounds: (range: DataGridOverlayRange | null) => DataGridStageOverlayBounds | null;
     customOverlays: ComputedRef<readonly DataGridTableStageCustomOverlay[]>;
+    perfTraceEnabled?: boolean;
 }
 export interface UseDataGridStageOverlaysResult {
     leftSelectionOverlaySegments: ComputedRef<readonly DataGridTableStageOverlaySegment[]>;

package/dist/stage/useDataGridStagePointerInteractions.d.ts

@@ -2,6 +2,7 @@ import { type Ref } from "vue";
 import type { DataGridTableMode } from "./dataGridTableStage.types";
 import type { DataGridOverlayRange } from "@affino/datagrid-vue";
 import type { DataGridTableStageBodyColumn, DataGridTableStageBodyRow } from "./dataGridTableStageBody.types";
+import { type DataGridInteractionModeInput } from "./dataGridMouseEventGuards";
 export interface UseDataGridStagePointerInteractionsOptions {
     mode: Readonly<Ref<DataGridTableMode>>;
     selection: Readonly<Ref<{
@@ -15,6 +16,8 @@ export interface UseDataGridStagePointerInteractionsOptions {
     displayRows: Readonly<Ref<readonly DataGridTableStageBodyRow[]>>;
     viewportRowStart: Readonly<Ref<number>>;
     fillActionMenuOpen: Ref<boolean>;
+    interactionModeInput?: Readonly<Ref<DataGridInteractionModeInput>>;
+    suppressHoverInteractions?: Readonly<Ref<boolean>>;
     isCellSelectedSafe: (rowOffset: number, columnIndex: number) => boolean;
     isCellEditableSafe: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
     isCellOnSelectionEdgeSafe: (rowOffset: number, columnIndex: number, edge: "top" | "right" | "bottom" | "left") => boolean;
@@ -25,6 +28,9 @@ export interface UseDataGridStagePointerInteractionsResult {
     handleCellMouseMove: (event: MouseEvent, rowOffset: number, columnIndex: number) => void;
     handleFillHandleMouseDown: (event: MouseEvent) => void;
     handleFillHandleDoubleClick: (event: MouseEvent) => void;
+    handleFillHandleTouchStart: (event: TouchEvent) => void;
+    handleFillHandleTouchMove: (event: TouchEvent) => void;
+    handleFillHandleTouchEnd: (event: TouchEvent) => void;
     resetGlobalFillDragCursor: () => void;
 }
 export declare function useDataGridStagePointerInteractions(options: UseDataGridStagePointerInteractionsOptions): UseDataGridStagePointerInteractionsResult;

package/dist/stage/useDataGridStageRenderApis.d.ts

@@ -62,6 +62,8 @@ export interface UseDataGridStageRenderApisOptions {
     isCellEditableSafe: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
     isEditingCellSafe: (row: DataGridTableStageBodyRow, columnKey: string) => boolean;
     isCellSelectedSafe: (rowOffset: number, columnIndex: number) => boolean;
+    isTouchSelectionAnchorHandleCell: (row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => boolean;
+    isTouchRangeMoveHandleCell: (row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => boolean;
     isSelectionAnchorCellSafe: (rowOffset: number, columnIndex: number) => boolean;
     shouldHighlightSelectedCellVisual: (rowOffset: number, columnIndex: number) => boolean;
     isCellInFillPreviewSafe: (rowOffset: number, columnIndex: number) => boolean;
@@ -96,6 +98,7 @@ export interface UseDataGridStageRenderApisOptions {
     bodyCellSelectionStyle: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number, columnIndex: number) => CSSProperties;
     resolveCellCustomStyle: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => CSSProperties;
     cellTabIndex: (rowOffset: number, columnIndex: number) => number;
+    cellAriaSelected: (rowOffset: number, columnIndex: number) => "true" | "false";
     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;
@@ -106,9 +109,20 @@ export interface UseDataGridStageRenderApisOptions {
     handleCellMouseMove: (event: MouseEvent, rowOffset: number, columnIndex: number) => void;
     clearRangeMoveHandleHover: () => void;
     handleCellKeydown: (event: KeyboardEvent, row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => void;
-    startInlineEditIfAllowed: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number) => void;
+    startInlineEditIfAllowed: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number, event?: MouseEvent) => void;
+    handleTouchSelectionHandleMouseDown: (event: MouseEvent) => void;
+    handleTouchSelectionHandleTouchStart: (event: TouchEvent, row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => void;
+    handleTouchSelectionHandleTouchMove: (event: TouchEvent) => void;
+    handleTouchSelectionHandleTouchEnd: (event: TouchEvent) => void;
+    handleTouchRangeMoveHandleMouseDown: (event: MouseEvent) => void;
+    handleTouchRangeMoveHandleTouchStart: (event: TouchEvent, row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => void;
+    handleTouchRangeMoveHandleTouchMove: (event: TouchEvent) => void;
+    handleTouchRangeMoveHandleTouchEnd: (event: TouchEvent) => void;
     handleFillHandleMouseDown: (event: MouseEvent) => void;
     handleFillHandleDoubleClick: (event: MouseEvent) => void;
+    handleFillHandleTouchStart: (event: TouchEvent) => void;
+    handleFillHandleTouchMove: (event: TouchEvent) => void;
+    handleFillHandleTouchEnd: (event: TouchEvent) => void;
     isSelectEditorCell: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
     resolveSelectEditorValue: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => string;
     resolveSelectEditorOptions: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => readonly DataGridTableStageSelectEditorOption[];

package/dist/stage/useDataGridStageRenderApis.grouped.d.ts

@@ -40,6 +40,8 @@ type CellRuntime = Readonly<Ref<{
     isCellEditableSafe: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => boolean;
     isEditingCellSafe: (row: DataGridTableStageBodyRow, columnKey: string) => boolean;
     isCellSelectedSafe: (rowOffset: number, columnIndex: number) => boolean;
+    isTouchSelectionAnchorHandleCell: (row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => boolean;
+    isTouchRangeMoveHandleCell: (row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => boolean;
     isSelectionAnchorCellSafe: (rowOffset: number, columnIndex: number) => boolean;
     shouldHighlightSelectedCellVisual: (rowOffset: number, columnIndex: number) => boolean;
     isCellInFillPreviewSafe: (rowOffset: number, columnIndex: number) => boolean;
@@ -56,6 +58,7 @@ type CellRuntime = Readonly<Ref<{
     bodyCellSelectionStyle: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number, columnIndex: number) => CSSProperties;
     resolveCellCustomStyle: (row: DataGridTableStageBodyRow, rowOffset: number, column: DataGridTableStageBodyColumn, columnIndex: number) => CSSProperties;
     cellTabIndex: (rowOffset: number, columnIndex: number) => number;
+    cellAriaSelected: (rowOffset: number, columnIndex: number) => "true" | "false";
     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;
@@ -66,9 +69,20 @@ type CellRuntime = Readonly<Ref<{
     handleCellMouseMove: (event: MouseEvent, rowOffset: number, columnIndex: number) => void;
     clearRangeMoveHandleHover: () => void;
     handleCellKeydown: (event: KeyboardEvent, row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => void;
-    startInlineEditIfAllowed: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number) => void;
+    startInlineEditIfAllowed: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number, event?: MouseEvent) => void;
+    handleTouchSelectionHandleMouseDown: (event: MouseEvent) => void;
+    handleTouchSelectionHandleTouchStart: (event: TouchEvent, row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => void;
+    handleTouchSelectionHandleTouchMove: (event: TouchEvent) => void;
+    handleTouchSelectionHandleTouchEnd: (event: TouchEvent) => void;
+    handleTouchRangeMoveHandleMouseDown: (event: MouseEvent) => void;
+    handleTouchRangeMoveHandleTouchStart: (event: TouchEvent, row: DataGridTableStageBodyRow, rowOffset: number, columnIndex: number) => void;
+    handleTouchRangeMoveHandleTouchMove: (event: TouchEvent) => void;
+    handleTouchRangeMoveHandleTouchEnd: (event: TouchEvent) => void;
     handleFillHandleMouseDown: (event: MouseEvent) => void;
     handleFillHandleDoubleClick: (event: MouseEvent) => void;
+    handleFillHandleTouchStart: (event: TouchEvent) => void;
+    handleFillHandleTouchMove: (event: TouchEvent) => void;
+    handleFillHandleTouchEnd: (event: TouchEvent) => void;
     shouldRenderCheckboxCell: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => boolean;
     checkboxIndicatorClass: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => Record<string, boolean>;
     checkboxIndicatorMarkClass: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => Record<string, boolean>;
@@ -100,7 +114,7 @@ type EditorRuntime = Readonly<Ref<{
         readDisplayCell: (row: DataGridTableStageBodyRow, columnKey: string) => string;
     }>>;
     editing: Readonly<Ref<DataGridTableStageEditingSection<Record<string, unknown>>>>;
-    startInlineEditIfAllowed: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number) => void;
+    startInlineEditIfAllowed: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn, rowOffset: number, event?: MouseEvent) => void;
     resolveCellEditorMode: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => "none" | "text" | "select" | "date" | "datetime";
     resolveSelectEditorOptions: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => readonly DataGridTableStageSelectEditorOption[];
     resolveSelectEditorOptionsLoader: (row: DataGridTableStageBodyRow, column: DataGridTableStageBodyColumn) => DataGridTableStageSelectEditorOptionsLoader | undefined;

package/dist/stage/useDataGridStageRowIndex.d.ts

@@ -7,6 +7,7 @@ export interface UseDataGridStageRowIndexOptions {
     layout: Readonly<Ref<DataGridTableStageLayoutSection>>;
     viewportRowStart: Readonly<Ref<number>>;
     selectionRange: Readonly<Ref<DataGridOverlayRange | null>>;
+    selectionRanges?: Readonly<Ref<readonly DataGridOverlayRange[]>>;
     visibleColumns: Readonly<Ref<readonly DataGridTableStageBodyColumn[]>>;
     isHoveredRow: (row: DataGridTableStageBodyRow, rowOffset: number) => boolean;
     isStripedRow: (row: DataGridTableStageBodyRow, rowOffset: number) => boolean;

package/dist/stage/useDataGridStageViewportRuntime.d.ts

@@ -1,11 +1,12 @@
 import { type ComponentPublicInstance, type Ref } from "vue";
 import type { DataGridTableStageViewportSection } from "./dataGridTableStage.types";
+type GridChromeRedrawMode = "full" | "center-scroll";
 export interface UseDataGridStageViewportRuntimeSyncers {
     syncBodyViewportMetrics: () => void;
     syncPinnedBottomViewportMetrics: () => void;
     syncPinnedBottomViewportScrollLeft: () => void;
-    scheduleGridChromeRedraw: (mode?: "full" | "center-scroll") => void;
-    flushGridChromeRedraw: (mode?: "full" | "center-scroll") => void;
+    scheduleGridChromeRedraw: (mode?: GridChromeRedrawMode) => void;
+    flushGridChromeRedraw: (mode?: GridChromeRedrawMode) => void;
     connectGridChromeResizeObserver: () => void;
     disconnectGridChromeResizeObserver: () => void;
 }
@@ -15,6 +16,7 @@ export interface UseDataGridStageViewportRuntimeOptions {
     gridChromeSyncers: Readonly<Ref<UseDataGridStageViewportRuntimeSyncers>>;
     leftPaneContentRef: Readonly<Ref<HTMLElement | null>>;
     rightPaneContentRef: Readonly<Ref<HTMLElement | null>>;
+    perfTraceEnabled?: boolean;
 }
 export interface UseDataGridStageViewportRuntimeResult {
     bodyViewportEl: Ref<HTMLElement | null>;
@@ -27,6 +29,9 @@ export interface UseDataGridStageViewportRuntimeResult {
     bodyViewportTopOffset: Ref<number>;
     headerShellHeight: Ref<number>;
     headerViewportClientWidth: Ref<number>;
+    isBodyViewportScrolling: Ref<boolean>;
+    isBodyViewportScrollIdle: Ref<boolean>;
+    runWhenBodyViewportScrollIdle: (callback: () => void) => void;
     captureBodyViewportRef: (value: Element | ComponentPublicInstance | null) => void;
     capturePinnedBottomViewportRef: (value: Element | ComponentPublicInstance | null) => void;
     handleCenterViewportScroll: (event: Event) => void;
@@ -35,3 +40,4 @@ export interface UseDataGridStageViewportRuntimeResult {
     handleBodyViewportWheel: (event: WheelEvent) => void;
 }
 export declare function useDataGridStageViewportRuntime(options: UseDataGridStageViewportRuntimeOptions): UseDataGridStageViewportRuntimeResult;
+export {};

package/dist/stage/useDataGridTableStageHistory.d.ts

@@ -1,3 +1,4 @@
+import type { DataGridAppHistoryRestorationState } from "@affino/datagrid-vue/app";
 import type { DataGridCopyRange } from "@affino/datagrid-vue/advanced";
 import type { DataGridHistoryController } from "../dataGridHistory";
 export interface DataGridTableStageHistoryAdapter {
@@ -27,6 +28,8 @@ export interface UseDataGridTableStageHistoryOptions<TRow extends Record<string,
     syncViewport: () => void;
     enabled?: boolean;
     maxHistoryDepth?: number;
+    captureRestorationState?: () => DataGridAppHistoryRestorationState | null;
+    applyRestorationState?: (state: DataGridAppHistoryRestorationState) => void | Promise<void>;
     history?: DataGridTableStageHistoryAdapter;
 }
 export interface UseDataGridTableStageHistoryResult extends DataGridHistoryController {

package/dist/stage/useDataGridTableStageRuntime.d.ts

@@ -81,6 +81,7 @@ export interface UseDataGridTableStageRuntimeOptions<TRow extends Record<string,
         getRow?: DataGridRowModel<TRow>["getRow"];
         getRowCount?: DataGridRowModel<TRow>["getRowCount"];
         getRowsInRange?: DataGridRowModel<TRow>["getRowsInRange"];
+        getLoadedRowIntervals?: DataGridRowModel<TRow>["getLoadedRowIntervals"];
         dataSource?: {
             resolveFillBoundary?: (request: DataGridAppResolveFillBoundaryRequest) => Promise<DataGridAppResolveFillBoundaryResult> | DataGridAppResolveFillBoundaryResult;
             commitFillOperation?: (request: {

package/dist/stage/useDataGridTableStageScrollSync.d.ts

@@ -6,10 +6,18 @@ export interface UseDataGridTableStageScrollSyncOptions {
     stopColumnResize: () => void;
     handleInteractionWindowMouseMove: (event: MouseEvent) => void;
     handleInteractionWindowMouseUp: () => void;
+    handleInteractionWindowPointerUp: () => void;
+    handleInteractionWindowPointerCancel: () => void;
+    handleInteractionWindowBlur: () => void;
+    handleInteractionWindowContextMenuCapture: (event: MouseEvent) => boolean;
     syncViewport: (event: Event) => void;
 }
 export interface UseDataGridTableStageScrollSyncResult {
     handleWindowMouseMove: (event: MouseEvent) => void;
+    handleWindowPointerUp: (event: PointerEvent) => void;
+    handleWindowPointerCancel: (event: PointerEvent) => void;
+    handleWindowBlur: () => void;
+    handleWindowContextMenuCapture: (event: MouseEvent) => boolean;
     handleHeaderWheel: (event: WheelEvent) => void;
     handleHeaderScroll: (event: Event) => void;
     handleWindowMouseUp: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@affino/datagrid-vue-app",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "description": "Declarative Vue DataGrid component for Affino",
   "type": "module",
   "main": "dist/index.js",
@@ -47,8 +47,8 @@
     "@affino/popover-vue": "^1.1.0",
     "@affino/datagrid-chrome": "0.1.1",
     "@affino/datagrid-gantt": "0.1.2",
-    "@affino/datagrid-vue": "0.3.44",
-    "@affino/datagrid-theme": "0.2.3"
+    "@affino/datagrid-theme": "0.2.3",
+    "@affino/datagrid-vue": "0.3.46"
   },
   "peerDependencies": {
     "vue": "^3.3.0"