@affino/datagrid-orchestration 0.1.0

package/dist/src/useDataGridGroupingSortOrchestration.js

@@ -0,0 +1,22 @@
+export function withGroupingSortPriority(model, groupByKey) {
+    if (groupByKey === "none") {
+        return model;
+    }
+    const withoutGroupKey = model.filter(entry => entry.key !== groupByKey);
+    const groupEntry = model.find(entry => entry.key === groupByKey);
+    return [{ key: groupByKey, direction: groupEntry?.direction ?? "asc" }, ...withoutGroupKey];
+}
+export function resolveDataGridSortSummary(model) {
+    if (!model.length) {
+        return "none";
+    }
+    return model
+        .map((entry, index) => `${index + 1}:${entry.key}:${entry.direction}`)
+        .join(" | ");
+}
+export function useDataGridGroupingSortOrchestration(options) {
+    return {
+        effectiveSortModel: withGroupingSortPriority(options.sortState, options.groupBy),
+        sortSummary: resolveDataGridSortSummary(options.sortState),
+    };
+}

package/dist/src/useDataGridHeaderContextActions.d.ts

@@ -0,0 +1,15 @@
+import type { DataGridContextMenuActionId } from "./dataGridContextMenuContracts";
+export interface UseDataGridHeaderContextActionsOptions {
+    isSortableColumn: (columnKey: string) => boolean;
+    applyExplicitSort: (columnKey: string, direction: "asc" | "desc" | null) => void;
+    openColumnFilter: (columnKey: string) => void;
+    estimateColumnAutoWidth: (columnKey: string) => number;
+    setColumnWidth: (columnKey: string, width: number) => void;
+    closeContextMenu: () => void;
+    setLastAction: (message: string) => void;
+}
+export interface UseDataGridHeaderContextActionsResult {
+    runHeaderContextAction: (action: DataGridContextMenuActionId, columnKey: string) => boolean;
+}
+export declare function useDataGridHeaderContextActions(options: UseDataGridHeaderContextActionsOptions): UseDataGridHeaderContextActionsResult;
+//# sourceMappingURL=useDataGridHeaderContextActions.d.ts.map

package/dist/src/useDataGridHeaderContextActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridHeaderContextActions.d.ts","sourceRoot":"","sources":["../../src/useDataGridHeaderContextActions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAA;AAEjF,MAAM,WAAW,sCAAsC;IACrD,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;IAChD,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAChF,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7C,uBAAuB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACtD,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1D,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CACzC;AAED,MAAM,WAAW,qCAAqC;IACpD,sBAAsB,EAAE,CAAC,MAAM,EAAE,2BAA2B,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;CAC5F;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,sCAAsC,GAC9C,qCAAqC,CA2CvC"}

package/dist/src/useDataGridHeaderContextActions.js

@@ -0,0 +1,41 @@
+export function useDataGridHeaderContextActions(options) {
+    function runHeaderContextAction(action, columnKey) {
+        if (!options.isSortableColumn(columnKey) && action !== "auto-size") {
+            return false;
+        }
+        if (action === "sort-asc") {
+            options.applyExplicitSort(columnKey, "asc");
+            options.setLastAction(`Sorted ${columnKey} asc`);
+            options.closeContextMenu();
+            return true;
+        }
+        if (action === "sort-desc") {
+            options.applyExplicitSort(columnKey, "desc");
+            options.setLastAction(`Sorted ${columnKey} desc`);
+            options.closeContextMenu();
+            return true;
+        }
+        if (action === "sort-clear") {
+            options.applyExplicitSort(columnKey, null);
+            options.setLastAction(`Sort cleared for ${columnKey}`);
+            options.closeContextMenu();
+            return true;
+        }
+        if (action === "filter") {
+            options.openColumnFilter(columnKey);
+            options.closeContextMenu();
+            return true;
+        }
+        if (action === "auto-size") {
+            const nextWidth = options.estimateColumnAutoWidth(columnKey);
+            options.setColumnWidth(columnKey, nextWidth);
+            options.setLastAction(`Auto-sized ${columnKey} to ${nextWidth}px`);
+            options.closeContextMenu();
+            return true;
+        }
+        return false;
+    }
+    return {
+        runHeaderContextAction,
+    };
+}

package/dist/src/useDataGridHeaderInteractionRouter.d.ts

@@ -0,0 +1,12 @@
+export interface UseDataGridHeaderInteractionRouterOptions {
+    isSortableColumn: (columnKey: string) => boolean;
+    applySortFromHeader: (columnKey: string, append: boolean) => void;
+    openHeaderContextMenu: (x: number, y: number, columnKey: string) => void;
+    contextMenuBlockedColumnKey?: string;
+}
+export interface UseDataGridHeaderInteractionRouterResult {
+    onHeaderCellClick: (columnKey: string, event: MouseEvent) => void;
+    onHeaderCellKeyDown: (columnKey: string, event: KeyboardEvent) => void;
+}
+export declare function useDataGridHeaderInteractionRouter(options: UseDataGridHeaderInteractionRouterOptions): UseDataGridHeaderInteractionRouterResult;
+//# sourceMappingURL=useDataGridHeaderInteractionRouter.d.ts.map

package/dist/src/useDataGridHeaderInteractionRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridHeaderInteractionRouter.d.ts","sourceRoot":"","sources":["../../src/useDataGridHeaderInteractionRouter.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yCAAyC;IACxD,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;IAChD,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IACjE,qBAAqB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IACxE,2BAA2B,CAAC,EAAE,MAAM,CAAA;CACrC;AAED,MAAM,WAAW,wCAAwC;IACvD,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;IACjE,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;CACvE;AAED,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,yCAAyC,GACjD,wCAAwC,CAsC1C"}

package/dist/src/useDataGridHeaderInteractionRouter.js

@@ -0,0 +1,35 @@
+export function useDataGridHeaderInteractionRouter(options) {
+    const contextMenuBlockedColumnKey = options.contextMenuBlockedColumnKey ?? "select";
+    function onHeaderCellClick(columnKey, event) {
+        if (!options.isSortableColumn(columnKey)) {
+            return;
+        }
+        options.applySortFromHeader(columnKey, event.shiftKey);
+    }
+    function onHeaderCellKeyDown(columnKey, event) {
+        if (event.key === "ContextMenu" || (event.shiftKey && event.key === "F10")) {
+            if (columnKey === contextMenuBlockedColumnKey) {
+                return;
+            }
+            event.preventDefault();
+            const target = event.currentTarget;
+            const rect = target?.getBoundingClientRect();
+            const x = rect ? rect.left + Math.min(rect.width - 8, Math.max(8, rect.width * 0.5)) : 24;
+            const y = rect ? rect.bottom - 6 : 24;
+            options.openHeaderContextMenu(x, y, columnKey);
+            return;
+        }
+        if (!options.isSortableColumn(columnKey)) {
+            return;
+        }
+        if (event.key !== "Enter" && event.key !== " ") {
+            return;
+        }
+        event.preventDefault();
+        options.applySortFromHeader(columnKey, event.shiftKey);
+    }
+    return {
+        onHeaderCellClick,
+        onHeaderCellKeyDown,
+    };
+}

package/dist/src/useDataGridHeaderLayerOrchestration.d.ts

@@ -0,0 +1,13 @@
+export interface DataGridHeaderLayerViewportGeometryInput {
+    headerViewportHeight: number;
+    bodyViewportWidth: number;
+    bodyViewportHeight: number;
+}
+export interface DataGridHeaderLayerViewportGeometry {
+    overlayTop: number;
+    overlayWidth: number;
+    overlayHeight: number;
+}
+export declare function resolveDataGridHeaderScrollSyncLeft(headerScrollLeft: number, bodyScrollLeft: number): number;
+export declare function resolveDataGridHeaderLayerViewportGeometry(input: DataGridHeaderLayerViewportGeometryInput): DataGridHeaderLayerViewportGeometry;
+//# sourceMappingURL=useDataGridHeaderLayerOrchestration.d.ts.map

package/dist/src/useDataGridHeaderLayerOrchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridHeaderLayerOrchestration.d.ts","sourceRoot":"","sources":["../../src/useDataGridHeaderLayerOrchestration.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,wCAAwC;IACvD,oBAAoB,EAAE,MAAM,CAAA;IAC5B,iBAAiB,EAAE,MAAM,CAAA;IACzB,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,mCAAmC;IAClD,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,wBAAgB,mCAAmC,CACjD,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,GACrB,MAAM,CAOR;AAED,wBAAgB,0CAA0C,CACxD,KAAK,EAAE,wCAAwC,GAC9C,mCAAmC,CASrC"}

package/dist/src/useDataGridHeaderLayerOrchestration.js

@@ -0,0 +1,18 @@
+export function resolveDataGridHeaderScrollSyncLeft(headerScrollLeft, bodyScrollLeft) {
+    const resolvedHeader = Number.isFinite(headerScrollLeft) ? headerScrollLeft : 0;
+    const resolvedBody = Number.isFinite(bodyScrollLeft) ? bodyScrollLeft : 0;
+    if (resolvedHeader === resolvedBody) {
+        return resolvedHeader;
+    }
+    return resolvedBody;
+}
+export function resolveDataGridHeaderLayerViewportGeometry(input) {
+    const headerViewportHeight = Math.max(0, Number(input.headerViewportHeight) || 0);
+    const bodyViewportWidth = Math.max(0, Number(input.bodyViewportWidth) || 0);
+    const bodyViewportHeight = Math.max(0, Number(input.bodyViewportHeight) || 0);
+    return {
+        overlayTop: headerViewportHeight,
+        overlayWidth: bodyViewportWidth,
+        overlayHeight: bodyViewportHeight,
+    };
+}

package/dist/src/useDataGridHeaderResizeOrchestration.d.ts

@@ -0,0 +1,43 @@
+export interface DataGridHeaderResizeState {
+    columnKey: string;
+    startClientX: number;
+    startWidth: number;
+    lastWidth: number;
+}
+export type DataGridHeaderResizeApplyMode = "sync" | "raf";
+export interface UseDataGridHeaderResizeOrchestrationOptions<TRow> {
+    resolveColumnBaseWidth: (columnKey: string) => number | null | undefined;
+    resolveColumnLabel: (columnKey: string) => string | null | undefined;
+    resolveRowsForAutoSize: () => readonly TRow[];
+    resolveCellText: (row: TRow, columnKey: string) => string;
+    resolveColumnWidthOverride: (columnKey: string) => number | null | undefined;
+    resolveColumnMinWidth: (columnKey: string) => number;
+    applyColumnWidth: (columnKey: string, width: number) => void;
+    isColumnResizable: (columnKey: string) => boolean;
+    isFillDragging: () => boolean;
+    stopFillSelection: (applyPreview: boolean) => void;
+    isDragSelecting: () => boolean;
+    stopDragSelection: () => void;
+    setLastAction: (message: string) => void;
+    autoSizeSampleLimit: number;
+    autoSizeCharWidth: number;
+    autoSizeHorizontalPadding: number;
+    autoSizeMaxWidth: number;
+    resizeApplyMode?: DataGridHeaderResizeApplyMode;
+    requestAnimationFrame?: (callback: FrameRequestCallback) => number;
+    cancelAnimationFrame?: (handle: number) => void;
+}
+export interface UseDataGridHeaderResizeOrchestrationResult {
+    getActiveColumnResize: () => DataGridHeaderResizeState | null;
+    isColumnResizing: () => boolean;
+    subscribe: (listener: (state: DataGridHeaderResizeState | null) => void) => () => void;
+    setColumnWidth: (columnKey: string, width: number) => void;
+    estimateColumnAutoWidth: (columnKey: string) => number;
+    onHeaderResizeHandleMouseDown: (columnKey: string, event: MouseEvent) => void;
+    onHeaderResizeHandleDoubleClick: (columnKey: string, event: MouseEvent) => void;
+    applyColumnResizeFromPointer: (clientX: number) => void;
+    stopColumnResize: () => void;
+    dispose: () => void;
+}
+export declare function useDataGridHeaderResizeOrchestration<TRow>(options: UseDataGridHeaderResizeOrchestrationOptions<TRow>): UseDataGridHeaderResizeOrchestrationResult;
+//# sourceMappingURL=useDataGridHeaderResizeOrchestration.d.ts.map

package/dist/src/useDataGridHeaderResizeOrchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridHeaderResizeOrchestration.d.ts","sourceRoot":"","sources":["../../src/useDataGridHeaderResizeOrchestration.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,6BAA6B,GAAG,MAAM,GAAG,KAAK,CAAA;AAE1D,MAAM,WAAW,2CAA2C,CAAC,IAAI;IAC/D,sBAAsB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IACxE,kBAAkB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IACpE,sBAAsB,EAAE,MAAM,SAAS,IAAI,EAAE,CAAA;IAC7C,eAAe,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACzD,0BAA0B,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IAC5E,qBAAqB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACpD,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5D,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;IACjD,cAAc,EAAE,MAAM,OAAO,CAAA;IAC7B,iBAAiB,EAAE,CAAC,YAAY,EAAE,OAAO,KAAK,IAAI,CAAA;IAClD,eAAe,EAAE,MAAM,OAAO,CAAA;IAC9B,iBAAiB,EAAE,MAAM,IAAI,CAAA;IAC7B,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,mBAAmB,EAAE,MAAM,CAAA;IAC3B,iBAAiB,EAAE,MAAM,CAAA;IACzB,yBAAyB,EAAE,MAAM,CAAA;IACjC,gBAAgB,EAAE,MAAM,CAAA;IACxB,eAAe,CAAC,EAAE,6BAA6B,CAAA;IAC/C,qBAAqB,CAAC,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,MAAM,CAAA;IAClE,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CAChD;AAED,MAAM,WAAW,0CAA0C;IACzD,qBAAqB,EAAE,MAAM,yBAAyB,GAAG,IAAI,CAAA;IAC7D,gBAAgB,EAAE,MAAM,OAAO,CAAA;IAC/B,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,yBAAyB,GAAG,IAAI,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;IACtF,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1D,uBAAuB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAA;IACtD,6BAA6B,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;IAC7E,+BAA+B,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;IAC/E,4BAA4B,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACvD,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,wBAAgB,oCAAoC,CAAC,IAAI,EACvD,OAAO,EAAE,2CAA2C,CAAC,IAAI,CAAC,GACzD,0CAA0C,CAsM5C"}

package/dist/src/useDataGridHeaderResizeOrchestration.js

@@ -0,0 +1,180 @@
+export function useDataGridHeaderResizeOrchestration(options) {
+    const resizeApplyMode = options.resizeApplyMode ?? "raf";
+    const requestFrame = options.requestAnimationFrame ?? (callback => window.requestAnimationFrame(callback));
+    const cancelFrame = options.cancelAnimationFrame ?? (handle => window.cancelAnimationFrame(handle));
+    let activeColumnResize = null;
+    let pendingResizeClientX = null;
+    let pendingResizeFrame = null;
+    const listeners = new Set();
+    function setActiveColumnResize(state) {
+        activeColumnResize = state;
+        listeners.forEach(listener => listener(state));
+    }
+    function subscribe(listener) {
+        listeners.add(listener);
+        listener(activeColumnResize);
+        return () => {
+            listeners.delete(listener);
+        };
+    }
+    function clampColumnWidth(columnKey, width) {
+        const minWidth = options.resolveColumnMinWidth(columnKey);
+        const rounded = Math.round(width);
+        return Math.max(minWidth, Math.min(options.autoSizeMaxWidth, rounded));
+    }
+    function resolveColumnCurrentWidth(columnKey) {
+        const override = options.resolveColumnWidthOverride(columnKey);
+        if (typeof override === "number") {
+            return override;
+        }
+        const baseWidth = options.resolveColumnBaseWidth(columnKey);
+        if (typeof baseWidth === "number") {
+            return baseWidth;
+        }
+        return options.resolveColumnMinWidth(columnKey);
+    }
+    function setColumnWidth(columnKey, width) {
+        options.applyColumnWidth(columnKey, clampColumnWidth(columnKey, width));
+    }
+    function cancelPendingResizeFrame() {
+        if (pendingResizeFrame === null) {
+            return;
+        }
+        cancelFrame(pendingResizeFrame);
+        pendingResizeFrame = null;
+    }
+    function canUseRaf() {
+        return resizeApplyMode === "raf" && typeof window !== "undefined";
+    }
+    function applyResizeFromClientX(clientX) {
+        if (!activeColumnResize) {
+            return false;
+        }
+        const delta = clientX - activeColumnResize.startClientX;
+        const nextWidth = clampColumnWidth(activeColumnResize.columnKey, activeColumnResize.startWidth + delta);
+        if (nextWidth === activeColumnResize.lastWidth) {
+            return false;
+        }
+        setColumnWidth(activeColumnResize.columnKey, nextWidth);
+        setActiveColumnResize({
+            ...activeColumnResize,
+            lastWidth: nextWidth,
+        });
+        return true;
+    }
+    function flushPendingResize() {
+        if (pendingResizeClientX === null) {
+            return false;
+        }
+        const nextClientX = pendingResizeClientX;
+        pendingResizeClientX = null;
+        return applyResizeFromClientX(nextClientX);
+    }
+    function schedulePendingResizeFlush() {
+        if (!canUseRaf()) {
+            flushPendingResize();
+            return;
+        }
+        if (pendingResizeFrame !== null) {
+            return;
+        }
+        pendingResizeFrame = requestFrame(() => {
+            pendingResizeFrame = null;
+            flushPendingResize();
+        });
+    }
+    function sampleRowsForAutoSize(rows, maxSamples) {
+        if (rows.length <= maxSamples) {
+            return rows;
+        }
+        const step = Math.max(1, Math.floor(rows.length / maxSamples));
+        const sample = [];
+        for (let index = 0; index < rows.length && sample.length < maxSamples; index += step) {
+            const row = rows[index];
+            if (row) {
+                sample.push(row);
+            }
+        }
+        return sample;
+    }
+    function estimateColumnAutoWidth(columnKey) {
+        const columnLabel = options.resolveColumnLabel(columnKey) ?? columnKey;
+        const rows = sampleRowsForAutoSize(options.resolveRowsForAutoSize(), options.autoSizeSampleLimit);
+        let maxTextLength = String(columnLabel).length;
+        for (const row of rows) {
+            const text = options.resolveCellText(row, columnKey);
+            if (text.length > maxTextLength) {
+                maxTextLength = text.length;
+            }
+        }
+        const estimated = maxTextLength * options.autoSizeCharWidth + options.autoSizeHorizontalPadding;
+        return clampColumnWidth(columnKey, estimated);
+    }
+    function onHeaderResizeHandleMouseDown(columnKey, event) {
+        if (event.button !== 0 || !options.isColumnResizable(columnKey)) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        if (options.isFillDragging()) {
+            options.stopFillSelection(false);
+        }
+        if (options.isDragSelecting()) {
+            options.stopDragSelection();
+        }
+        cancelPendingResizeFrame();
+        pendingResizeClientX = null;
+        const startWidth = resolveColumnCurrentWidth(columnKey);
+        setActiveColumnResize({
+            columnKey,
+            startClientX: event.clientX,
+            startWidth,
+            lastWidth: startWidth,
+        });
+    }
+    function onHeaderResizeHandleDoubleClick(columnKey, event) {
+        if (!options.isColumnResizable(columnKey)) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        const nextWidth = estimateColumnAutoWidth(columnKey);
+        setColumnWidth(columnKey, nextWidth);
+        options.setLastAction(`Auto-sized ${columnKey} to ${nextWidth}px`);
+    }
+    function applyColumnResizeFromPointer(clientX) {
+        if (!activeColumnResize) {
+            return;
+        }
+        pendingResizeClientX = clientX;
+        schedulePendingResizeFlush();
+    }
+    function stopColumnResize() {
+        if (!activeColumnResize) {
+            return;
+        }
+        flushPendingResize();
+        cancelPendingResizeFrame();
+        pendingResizeClientX = null;
+        const state = activeColumnResize;
+        setActiveColumnResize(null);
+        options.setLastAction(`Resized ${state.columnKey} to ${state.lastWidth}px`);
+    }
+    function dispose() {
+        cancelPendingResizeFrame();
+        pendingResizeClientX = null;
+        setActiveColumnResize(null);
+    }
+    return {
+        getActiveColumnResize: () => activeColumnResize,
+        isColumnResizing: () => activeColumnResize !== null,
+        subscribe,
+        setColumnWidth,
+        estimateColumnAutoWidth,
+        onHeaderResizeHandleMouseDown,
+        onHeaderResizeHandleDoubleClick,
+        applyColumnResizeFromPointer,
+        stopColumnResize,
+        dispose,
+    };
+}

package/dist/src/useDataGridHeaderSortOrchestration.d.ts

@@ -0,0 +1,20 @@
+import type { DataGridSortState } from "@affino/datagrid-core";
+import type { DataGridWritableRef } from "./dataGridWritableRef";
+export interface UseDataGridHeaderSortOrchestrationOptions {
+    sortState: DataGridWritableRef<readonly DataGridSortState[]>;
+    isSortableColumn: (columnKey: string) => boolean;
+}
+export interface DataGridHeaderSortEntry {
+    entry: DataGridSortState;
+    index: number;
+}
+export interface UseDataGridHeaderSortOrchestrationResult {
+    getSortEntry: (columnKey: string) => DataGridHeaderSortEntry | null;
+    getHeaderSortDirection: (columnKey: string) => "asc" | "desc" | null;
+    getHeaderSortPriority: (columnKey: string) => number | null;
+    getHeaderAriaSort: (columnKey: string) => "none" | "ascending" | "descending";
+    applySortFromHeader: (columnKey: string, keepExisting: boolean) => void;
+    applyExplicitSort: (columnKey: string, direction: "asc" | "desc" | null) => void;
+}
+export declare function useDataGridHeaderSortOrchestration(options: UseDataGridHeaderSortOrchestrationOptions): UseDataGridHeaderSortOrchestrationResult;
+//# sourceMappingURL=useDataGridHeaderSortOrchestration.d.ts.map

package/dist/src/useDataGridHeaderSortOrchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridHeaderSortOrchestration.d.ts","sourceRoot":"","sources":["../../src/useDataGridHeaderSortOrchestration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE,MAAM,WAAW,yCAAyC;IACxD,SAAS,EAAE,mBAAmB,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAAA;IAC5D,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;CACjD;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,iBAAiB,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,wCAAwC;IACvD,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,uBAAuB,GAAG,IAAI,CAAA;IACnE,sBAAsB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,KAAK,GAAG,MAAM,GAAG,IAAI,CAAA;IACpE,qBAAqB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IAC3D,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,WAAW,GAAG,YAAY,CAAA;IAC7E,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,KAAK,IAAI,CAAA;IACvE,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;CACjF;AAYD,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,yCAAyC,GACjD,wCAAwC,CAsF1C"}

package/dist/src/useDataGridHeaderSortOrchestration.js

@@ -0,0 +1,86 @@
+function cycleDirection(current) {
+    if (current === null) {
+        return "asc";
+    }
+    if (current === "asc") {
+        return "desc";
+    }
+    return null;
+}
+export function useDataGridHeaderSortOrchestration(options) {
+    function getSortEntry(columnKey) {
+        const index = options.sortState.value.findIndex(entry => entry.key === columnKey);
+        if (index < 0) {
+            return null;
+        }
+        const entry = options.sortState.value[index];
+        if (!entry) {
+            return null;
+        }
+        return { entry, index };
+    }
+    function getHeaderSortDirection(columnKey) {
+        return getSortEntry(columnKey)?.entry.direction ?? null;
+    }
+    function getHeaderSortPriority(columnKey) {
+        const entry = getSortEntry(columnKey);
+        if (!entry) {
+            return null;
+        }
+        return entry.index + 1;
+    }
+    function getHeaderAriaSort(columnKey) {
+        const direction = getHeaderSortDirection(columnKey);
+        if (direction === "asc") {
+            return "ascending";
+        }
+        if (direction === "desc") {
+            return "descending";
+        }
+        return "none";
+    }
+    function applySortFromHeader(columnKey, keepExisting) {
+        if (!options.isSortableColumn(columnKey)) {
+            return;
+        }
+        const existing = getSortEntry(columnKey);
+        const nextDirection = cycleDirection(existing?.entry.direction ?? null);
+        const nextState = keepExisting
+            ? [...options.sortState.value]
+            : [];
+        if (existing) {
+            nextState.splice(existing.index, 1);
+        }
+        if (nextDirection !== null) {
+            nextState.push({ key: columnKey, direction: nextDirection });
+        }
+        if (nextState.length === options.sortState.value.length) {
+            const same = nextState.every((entry, index) => {
+                const previous = options.sortState.value[index];
+                return previous?.key === entry.key && previous?.direction === entry.direction;
+            });
+            if (same) {
+                return;
+            }
+        }
+        options.sortState.value = nextState;
+    }
+    function applyExplicitSort(columnKey, direction) {
+        if (!options.isSortableColumn(columnKey)) {
+            return;
+        }
+        if (direction === null) {
+            options.sortState.value = options.sortState.value.filter(entry => entry.key !== columnKey);
+            return;
+        }
+        options.sortState.value = [{ key: columnKey, direction }];
+    }
+    return {
+        getSortEntry,
+        getHeaderSortDirection,
+        getHeaderSortPriority,
+        getHeaderAriaSort,
+        applySortFromHeader,
+        applyExplicitSort,
+    };
+}

package/dist/src/useDataGridHistoryActionRunner.d.ts

@@ -0,0 +1,15 @@
+export interface UseDataGridHistoryActionRunnerOptions {
+    hasInlineEditor: () => boolean;
+    commitInlineEdit: () => void;
+    closeContextMenu: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    runHistoryAction: (direction: "undo" | "redo") => Promise<string | null>;
+    setLastAction: (message: string) => void;
+    onError?: (direction: "undo" | "redo", error: unknown) => void;
+}
+export interface UseDataGridHistoryActionRunnerResult {
+    runHistoryAction: (direction: "undo" | "redo", trigger: "keyboard" | "control") => Promise<boolean>;
+}
+export declare function useDataGridHistoryActionRunner(options: UseDataGridHistoryActionRunnerOptions): UseDataGridHistoryActionRunnerResult;
+//# sourceMappingURL=useDataGridHistoryActionRunner.d.ts.map

package/dist/src/useDataGridHistoryActionRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridHistoryActionRunner.d.ts","sourceRoot":"","sources":["../../src/useDataGridHistoryActionRunner.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qCAAqC;IACpD,eAAe,EAAE,MAAM,OAAO,CAAA;IAC9B,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,OAAO,EAAE,MAAM,OAAO,CAAA;IACtB,OAAO,EAAE,MAAM,OAAO,CAAA;IACtB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IACxE,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CAC/D;AAED,MAAM,WAAW,oCAAoC;IACnD,gBAAgB,EAAE,CAChB,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,OAAO,EAAE,UAAU,GAAG,SAAS,KAC5B,OAAO,CAAC,OAAO,CAAC,CAAA;CACtB;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,qCAAqC,GAC7C,oCAAoC,CAwCtC"}

package/dist/src/useDataGridHistoryActionRunner.js

@@ -0,0 +1,35 @@
+export function useDataGridHistoryActionRunner(options) {
+    async function runHistoryAction(direction, trigger) {
+        if (options.hasInlineEditor()) {
+            options.commitInlineEdit();
+        }
+        options.closeContextMenu();
+        if (direction === "undo" && !options.canUndo()) {
+            options.setLastAction("Nothing to undo");
+            return false;
+        }
+        if (direction === "redo" && !options.canRedo()) {
+            options.setLastAction("Nothing to redo");
+            return false;
+        }
+        try {
+            const committedId = await options.runHistoryAction(direction);
+            if (!committedId) {
+                options.setLastAction(direction === "undo" ? "Nothing to undo" : "Nothing to redo");
+                return false;
+            }
+            options.setLastAction(direction === "undo"
+                ? `Undo ${committedId} (${trigger})`
+                : `Redo ${committedId} (${trigger})`);
+            return true;
+        }
+        catch (error) {
+            options.onError?.(direction, error);
+            options.setLastAction(direction === "undo" ? "Undo failed" : "Redo failed");
+            return false;
+        }
+    }
+    return {
+        runHistoryAction,
+    };
+}

package/dist/src/useDataGridInlineEditOrchestration.d.ts

@@ -0,0 +1,46 @@
+export type DataGridInlineEditorMode = "text" | "select";
+export interface DataGridInlineEditorState<TColumnKey extends string> {
+    rowId: string;
+    columnKey: TColumnKey;
+    draft: string;
+    mode: DataGridInlineEditorMode;
+}
+export interface DataGridInlineEditTarget<TColumnKey extends string> {
+    rowId: string;
+    columnKey: TColumnKey;
+}
+export interface UseDataGridInlineEditOrchestrationOptions<TRow, TColumnKey extends string, TRange = unknown, TSnapshot = unknown> {
+    sourceRows: () => readonly TRow[];
+    setSourceRows: (rows: readonly TRow[]) => void;
+    cloneRow: (row: TRow) => TRow;
+    resolveRowId: (row: TRow) => string;
+    resolveCellValue: (row: TRow, columnKey: string) => unknown;
+    isEditableColumn: (columnKey: string) => columnKey is TColumnKey;
+    isSelectColumn?: (columnKey: string) => boolean;
+    resolveRowLabel?: (row: TRow) => string;
+    applyEditedValue: (row: TRow, columnKey: TColumnKey, draft: string) => void;
+    finalizeEditedRow?: (row: TRow, columnKey: TColumnKey, draft: string) => void;
+    focusInlineEditor?: (rowId: string, columnKey: TColumnKey, mode: DataGridInlineEditorMode, openPicker: boolean) => void | Promise<void>;
+    setLastAction?: (message: string) => void;
+    captureBeforeSnapshot?: () => TSnapshot;
+    resolveAffectedRange?: (target: DataGridInlineEditTarget<TColumnKey>) => TRange | null;
+    recordIntentTransaction?: (descriptor: {
+        intent: "edit";
+        label: string;
+        affectedRange: TRange | null;
+    }, beforeSnapshot: TSnapshot) => Promise<void>;
+}
+export interface UseDataGridInlineEditOrchestrationResult<TRow, TColumnKey extends string> {
+    getInlineEditor: () => DataGridInlineEditorState<TColumnKey> | null;
+    subscribeInlineEditor: (listener: (editor: DataGridInlineEditorState<TColumnKey> | null) => void) => () => void;
+    isEditingCell: (rowId: string, columnKey: string) => boolean;
+    isSelectEditorCell: (rowId: string, columnKey: string) => boolean;
+    beginInlineEdit: (row: TRow, columnKey: string, mode?: DataGridInlineEditorMode, openPicker?: boolean) => boolean;
+    cancelInlineEdit: () => void;
+    commitInlineEdit: () => boolean;
+    updateEditorDraft: (value: string) => void;
+    onEditorInput: (event: Event) => void;
+    onEditorSelectChange: (value: string | number) => boolean;
+}
+export declare function useDataGridInlineEditOrchestration<TRow, TColumnKey extends string, TRange = unknown, TSnapshot = unknown>(options: UseDataGridInlineEditOrchestrationOptions<TRow, TColumnKey, TRange, TSnapshot>): UseDataGridInlineEditOrchestrationResult<TRow, TColumnKey>;
+//# sourceMappingURL=useDataGridInlineEditOrchestration.d.ts.map

package/dist/src/useDataGridInlineEditOrchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataGridInlineEditOrchestration.d.ts","sourceRoot":"","sources":["../../src/useDataGridInlineEditOrchestration.ts"],"names":[],"mappings":"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"}