@affino/datagrid-vue 0.1.0

package/dist/composables/useTableColumnBindings.js

@@ -0,0 +1,72 @@
+import { computed } from "vue";
+export function useTableColumnBindings({ headerRenderableEntries, visibleColumnEntries, columnTrackStartMap, localColumns, columnWidthDomMap, bodyCellClass, isColumnSticky, getStickySide, getStickyLeftOffset, getStickyRightOffset, getAriaColIndex, }) {
+    const visibleColumnIndexMap = computed(() => {
+        const map = new Map();
+        visibleColumnEntries.value.forEach(entry => {
+            const columnKey = entry.metric.column.key;
+            const columnIndex = entry.metric.index;
+            if (Number.isInteger(columnIndex)) {
+                map.set(columnKey, columnIndex);
+            }
+        });
+        return map;
+    });
+    const getColumnIndex = (columnKey) => {
+        const visibleIndex = visibleColumnIndexMap.value.get(columnKey);
+        if (visibleIndex != null) {
+            return visibleIndex;
+        }
+        const fallbackIndex = localColumns.value.findIndex(column => column.key === columnKey);
+        if (fallbackIndex !== -1) {
+            return fallbackIndex;
+        }
+        const trackEntry = columnTrackStartMap.value.get(columnKey);
+        if (trackEntry != null) {
+            return trackEntry - 1;
+        }
+        return 0;
+    };
+    const columnIndexToKey = computed(() => {
+        const map = new Map();
+        headerRenderableEntries.value.forEach(entry => {
+            const columnKey = entry.metric.column.key;
+            const columnIndex = getColumnIndex(columnKey);
+            if (Number.isInteger(columnIndex)) {
+                map.set(columnIndex, columnKey);
+            }
+        });
+        return map;
+    });
+    const bodyColumnBindings = computed(() => {
+        const bindings = new Map();
+        for (const entry of headerRenderableEntries.value) {
+            const column = entry.metric.column;
+            const columnIndex = getColumnIndex(column.key);
+            bindings.set(column.key, {
+                column,
+                columnIndex,
+                visualWidth: columnWidthDomMap.value.get(column.key) ?? 0,
+                cellClass: bodyCellClass(column),
+                sticky: isColumnSticky(column),
+                stickySide: getStickySide(column),
+                stickyLeftOffset: getStickyLeftOffset(column),
+                stickyRightOffset: getStickyRightOffset(column),
+                ariaColIndex: getAriaColIndex(columnIndex),
+            });
+        }
+        return bindings;
+    });
+    const getBodyColumnBinding = (columnKey) => {
+        const binding = bodyColumnBindings.value.get(columnKey);
+        if (!binding) {
+            throw new Error(`Missing body column binding for key: ${columnKey}`);
+        }
+        return binding;
+    };
+    return {
+        getColumnIndex,
+        columnIndexToKey,
+        bodyColumnBindings,
+        getBodyColumnBinding,
+    };
+}

package/dist/composables/useTableColumnPinning.d.ts

@@ -0,0 +1,17 @@
+import type { Ref } from "vue";
+import type { UiTableColumn } from "../../core/types";
+import type { ColumnPinPosition } from "../context";
+interface UseTableColumnPinningOptions {
+    localColumns: Ref<UiTableColumn[]>;
+    reorderColumns: (columns: UiTableColumn[]) => void;
+    getStoredPinState: () => Record<string, ColumnPinPosition> | null | undefined;
+}
+export interface UseTableColumnPinningResult {
+    resolveColumnPinState: (column: UiTableColumn) => ColumnPinPosition;
+    applyStoredPinState: () => void;
+    reorderPinnedColumns: () => void;
+    setColumnPin: (columnKey: string, position: ColumnPinPosition) => void;
+}
+export declare function useTableColumnPinning(options: UseTableColumnPinningOptions): UseTableColumnPinningResult;
+export {};
+//# sourceMappingURL=useTableColumnPinning.d.ts.map

package/dist/composables/useTableColumnPinning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTableColumnPinning.d.ts","sourceRoot":"","sources":["../../src/composables/useTableColumnPinning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAE9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGnD,UAAU,4BAA4B;IACpC,YAAY,EAAE,GAAG,CAAC,aAAa,EAAE,CAAC,CAAA;IAClC,cAAc,EAAE,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,IAAI,CAAA;IAClD,iBAAiB,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;CAC9E;AAED,MAAM,WAAW,2BAA2B;IAC1C,qBAAqB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,iBAAiB,CAAA;IACnE,mBAAmB,EAAE,MAAM,IAAI,CAAA;IAC/B,oBAAoB,EAAE,MAAM,IAAI,CAAA;IAChC,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,KAAK,IAAI,CAAA;CACvE;AAUD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,2BAA2B,CA2CxG"}

package/dist/composables/useTableColumnPinning.js

@@ -0,0 +1,49 @@
+import { normalizeColumnPinInput, resolveColumnPinPosition } from "../adapters/columnPinNormalization";
+function applyPinProps(column, position) {
+    const normalized = normalizeColumnPinInput(column);
+    if (normalized.isSystem) {
+        return { ...normalized, pin: "left" };
+    }
+    return { ...normalized, pin: position };
+}
+export function useTableColumnPinning(options) {
+    const resolveColumnPinState = (column) => {
+        return resolveColumnPinPosition(column);
+    };
+    const applyStoredPinState = () => {
+        const stored = options.getStoredPinState();
+        if (!stored)
+            return;
+        options.localColumns.value = options.localColumns.value.map(column => {
+            if (column.isSystem)
+                return column;
+            const position = stored[column.key] ?? "none";
+            return applyPinProps(column, position);
+        });
+    };
+    const reorderPinnedColumns = () => {
+        const columns = options.localColumns.value;
+        const left = columns.filter(column => !column.isSystem && resolveColumnPinState(column) === "left");
+        const right = columns.filter(column => !column.isSystem && resolveColumnPinState(column) === "right");
+        if (!left.length && !right.length)
+            return;
+        const systemColumns = columns.filter(column => column.isSystem);
+        const middle = columns.filter(column => !column.isSystem && resolveColumnPinState(column) === "none");
+        const desiredOrder = [...systemColumns, ...left, ...middle, ...right];
+        const currentOrderKey = columns.map(column => column.key).join("|");
+        const desiredOrderKey = desiredOrder.map(column => column.key).join("|");
+        if (currentOrderKey === desiredOrderKey)
+            return;
+        options.reorderColumns(desiredOrder);
+    };
+    const setColumnPin = (columnKey, position) => {
+        options.localColumns.value = options.localColumns.value.map(column => column.key === columnKey ? applyPinProps(column, position) : column);
+        reorderPinnedColumns();
+    };
+    return {
+        resolveColumnPinState,
+        applyStoredPinState,
+        reorderPinnedColumns,
+        setColumnPin,
+    };
+}

package/dist/composables/useTableDataModel.d.ts

@@ -0,0 +1,46 @@
+import { type ComputedRef } from "vue";
+import type { NormalizedTableProps } from "../../core/config/tableConfig";
+import type { UiTableLazyLoadReason, UiTableSortState, UiTableFilterSnapshot } from "../../core/types";
+import type { EventArgs, HostEventName } from "../../core/runtime/tableRuntime";
+type EmitHostEvent = <K extends HostEventName>(name: K, ...args: EventArgs<K>) => void;
+type ServerSortResolver = () => UiTableSortState[];
+type ServerFilterResolver = () => UiTableFilterSnapshot | null;
+interface UseTableDataModelOptions {
+    normalizedProps: ComputedRef<NormalizedTableProps>;
+    emit: (event: string, ...args: any[]) => void;
+    fireEvent: EmitHostEvent;
+    getServerSorts: ServerSortResolver;
+    getServerFilters: ServerFilterResolver;
+}
+export declare function useTableDataModel(options: UseTableDataModelOptions): {
+    internalLazyLoading: import("vue").Ref<boolean, boolean>;
+    isLazyMode: ComputedRef<boolean>;
+    serverSideModel: ComputedRef<any>;
+    serverSideFiltering: ComputedRef<any>;
+    serverSideSorting: ComputedRef<any>;
+    autoLazyOnScroll: ComputedRef<any>;
+    autoLazyOnMount: ComputedRef<any>;
+    resolvedRows: ComputedRef<any>;
+    loadingState: ComputedRef<any>;
+    computedHasMore: ComputedRef<any>;
+    requestPage: (page: number, reason?: UiTableLazyLoadReason) => Promise<void>;
+    requestNextPage: (reason?: UiTableLazyLoadReason) => Promise<void>;
+    resetLazyPaging: (options?: {
+        clearRows?: boolean;
+    }) => void;
+    triggerServerReload: (reason: UiTableLazyLoadReason) => Promise<void>;
+    scheduleServerReload: (reason: UiTableLazyLoadReason) => void;
+    serverRowModel: import("./useServerRowModel").ServerRowModel<any>;
+    serverRowBlocks: ComputedRef<Map<number, any[]>>;
+    serverRowTotal: ComputedRef<number>;
+    serverRows: ComputedRef<any[]>;
+    clearPlaceholderRows: () => void;
+    isServerPlaceholderRow: (row: unknown) => row is Record<string, unknown>;
+    lazyPendingPage: import("vue").Ref<number | null, number | null>;
+    lazyErrorState: import("vue").Ref<unknown, unknown>;
+    lastServerFilterFingerprint: import("vue").Ref<string | null, string | null>;
+    lastServerSortFingerprint: import("vue").Ref<string | null, string | null>;
+    setScrollToTopForServer: (fn: (() => void) | null) => void;
+};
+export {};
+//# sourceMappingURL=useTableDataModel.d.ts.map

package/dist/composables/useTableDataModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTableDataModel.d.ts","sourceRoot":"","sources":["../../src/composables/useTableDataModel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgE,KAAK,WAAW,EAAE,MAAM,KAAK,CAAA;AACpG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AACzE,OAAO,KAAK,EAEV,qBAAqB,EAErB,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAI/E,KAAK,aAAa,GAAG,CAAC,CAAC,SAAS,aAAa,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;AAEtF,KAAK,kBAAkB,GAAG,MAAM,gBAAgB,EAAE,CAAA;AAClD,KAAK,oBAAoB,GAAG,MAAM,qBAAqB,GAAG,IAAI,CAAA;AAE9D,UAAU,wBAAwB;IAChC,eAAe,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAA;IAClD,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;IAC7C,SAAS,EAAE,aAAa,CAAA;IACxB,cAAc,EAAE,kBAAkB,CAAA;IAClC,gBAAgB,EAAE,oBAAoB,CAAA;CACvC;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB;;;;;;;;;;;wBAyRhC,MAAM,WAAU,qBAAqB;+BA2D/B,qBAAqB;gCAKzB;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;kCAyDf,qBAAqB;mCAf1B,qBAAqB;;;;;;kCAkCtB,OAAO,KAAG,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;kCAIxC,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI;EAgCzD"}

package/dist/composables/useTableDataModel.js

@@ -0,0 +1,411 @@
+import { computed, onBeforeUnmount, onMounted, ref, shallowRef, watch } from "vue";
+import { useServerRowModel } from "./useServerRowModel";
+const SERVER_PLACEHOLDER_FLAG = "__uiTableServerPlaceholder__";
+export function useTableDataModel(options) {
+    const internalLazyLoading = ref(false);
+    const propRows = computed(() => options.normalizedProps.value.rows);
+    const resolvedPageSize = computed(() => options.normalizedProps.value.pageSize);
+    const isLazyMode = computed(() => typeof options.normalizedProps.value.lazyLoader === "function");
+    const serverSideModel = computed(() => isLazyMode.value && options.normalizedProps.value.serverSideModel);
+    const serverSideFiltering = computed(() => serverSideModel.value);
+    const serverSideSorting = computed(() => serverSideModel.value);
+    const autoLazyOnScroll = computed(() => isLazyMode.value && options.normalizedProps.value.autoLoadOnScroll);
+    const autoLazyOnMount = computed(() => isLazyMode.value && options.normalizedProps.value.loadOnMount);
+    const lazyPendingPage = ref(null);
+    const lastCompletedPage = ref(-1);
+    const lastKnownRowLength = ref(0);
+    const lazyErrorState = ref(null);
+    const serverRowLoadReason = ref("manual");
+    const scrollToTopForServer = shallowRef(null);
+    const serverRowModel = useServerRowModel({
+        blockSize: resolvedPageSize.value,
+        loadBlock: async ({ start, limit, signal, background }) => {
+            const loader = options.normalizedProps.value.lazyLoader;
+            if (!loader) {
+                return { rows: [] };
+            }
+            const blockSize = limit || resolvedPageSize.value;
+            const page = Math.floor(start / Math.max(1, blockSize));
+            const reason = background ? "scroll" : serverRowLoadReason.value;
+            const sorts = serverSideSorting.value ? options.getServerSorts() : undefined;
+            const filtersSnapshot = serverSideFiltering.value ? options.getServerFilters() : null;
+            const eventContext = {
+                page,
+                pageSize: blockSize,
+                offset: start,
+                totalLoaded: serverRowLoadedCount.value,
+                reason,
+                sorts,
+                filters: filtersSnapshot,
+                mode: "block",
+            };
+            if (!background) {
+                lazyPendingPage.value = page;
+                internalLazyLoading.value = true;
+                lazyErrorState.value = null;
+                options.emit("lazy-load", eventContext);
+                options.fireEvent("lazyLoad", eventContext);
+            }
+            try {
+                const response = await loader({
+                    ...eventContext,
+                    signal,
+                    background,
+                    blockSize,
+                });
+                if (signal.aborted) {
+                    return { rows: [] };
+                }
+                let rows = [];
+                let total;
+                if (Array.isArray(response)) {
+                    rows = response;
+                }
+                else if (response && typeof response === "object") {
+                    const payload = response;
+                    if (Array.isArray(payload.rows)) {
+                        rows = payload.rows;
+                    }
+                    if (typeof payload.total === "number") {
+                        total = payload.total;
+                    }
+                }
+                if (!background) {
+                    const completion = { ...eventContext };
+                    options.emit("lazy-load-complete", completion);
+                    options.fireEvent("lazyLoadComplete", completion);
+                }
+                return total != null ? { rows, total } : rows;
+            }
+            catch (error) {
+                if (!background) {
+                    lazyErrorState.value = error;
+                    const payload = { ...eventContext, error };
+                    options.emit("lazy-load-error", payload);
+                    options.fireEvent("lazyLoadError", payload);
+                }
+                throw error;
+            }
+            finally {
+                if (!background) {
+                    if (lazyPendingPage.value === page) {
+                        lazyPendingPage.value = null;
+                    }
+                    internalLazyLoading.value = false;
+                    serverRowLoadReason.value = "scroll";
+                }
+            }
+        },
+    });
+    const serverRowBlocks = computed(() => serverRowModel.blocks.value);
+    const serverRowLoadedCount = computed(() => {
+        let total = 0;
+        serverRowBlocks.value.forEach(block => {
+            total += block.length;
+        });
+        return total;
+    });
+    const placeholderRowCache = new Map();
+    function getPlaceholderRow(index) {
+        const cached = placeholderRowCache.get(index);
+        if (cached) {
+            return cached;
+        }
+        const placeholder = {
+            [SERVER_PLACEHOLDER_FLAG]: true,
+            __rowIndex: index,
+        };
+        placeholderRowCache.set(index, placeholder);
+        return placeholder;
+    }
+    function clearPlaceholderRows() {
+        placeholderRowCache.clear();
+    }
+    const serverRowTotal = computed(() => {
+        const explicit = options.normalizedProps.value.totalRows;
+        if (typeof explicit === "number" && Number.isFinite(explicit)) {
+            return Math.max(0, Math.floor(explicit));
+        }
+        const modelTotal = serverRowModel.total.value;
+        if (typeof modelTotal === "number" && Number.isFinite(modelTotal)) {
+            return Math.max(0, Math.floor(modelTotal));
+        }
+        let max = 0;
+        serverRowBlocks.value.forEach((rows, start) => {
+            if (rows.length) {
+                max = Math.max(max, start + rows.length);
+            }
+        });
+        return max;
+    });
+    const serverRows = computed(() => {
+        if (!serverSideModel.value) {
+            return [];
+        }
+        const total = serverRowTotal.value;
+        if (!Number.isFinite(total) || total <= 0) {
+            const partial = [];
+            serverRowBlocks.value.forEach(blockRows => {
+                if (blockRows.length) {
+                    for (let index = 0; index < blockRows.length; index += 1) {
+                        const row = blockRows[index];
+                        if (row != null) {
+                            partial.push(row);
+                        }
+                    }
+                }
+            });
+            return partial;
+        }
+        const buffer = new Array(total);
+        serverRowBlocks.value.forEach((blockRows, start) => {
+            for (let index = 0; index < blockRows.length; index += 1) {
+                const row = blockRows[index];
+                if (row != null) {
+                    const absolute = start + index;
+                    buffer[absolute] = row;
+                    placeholderRowCache.delete(absolute);
+                }
+            }
+        });
+        for (let index = 0; index < total; index += 1) {
+            if (buffer[index] === undefined) {
+                buffer[index] = getPlaceholderRow(index);
+            }
+        }
+        return buffer;
+    });
+    const resolvedRows = computed(() => (serverSideModel.value ? serverRows.value : propRows.value));
+    const loadingState = computed(() => options.normalizedProps.value.loading || internalLazyLoading.value);
+    const computedHasMore = computed(() => {
+        if (serverSideModel.value) {
+            return false;
+        }
+        const explicit = options.normalizedProps.value.hasMore;
+        if (explicit != null) {
+            return explicit;
+        }
+        const totalRows = options.normalizedProps.value.totalRows;
+        if (totalRows != null) {
+            return resolvedRows.value.length < totalRows;
+        }
+        return true;
+    });
+    watch(() => resolvedRows.value.length, (length, previousLength) => {
+        lastKnownRowLength.value = length;
+        const derivedPage = Math.max(-1, Math.ceil(length / Math.max(1, resolvedPageSize.value)) - 1);
+        lastCompletedPage.value = derivedPage;
+        if (lazyPendingPage.value != null && derivedPage >= lazyPendingPage.value) {
+            lazyPendingPage.value = null;
+            internalLazyLoading.value = false;
+        }
+        if (previousLength !== undefined && length < (previousLength ?? 0)) {
+            lazyErrorState.value = null;
+        }
+    }, { immediate: true });
+    watch(() => options.normalizedProps.value.loading, value => {
+        if (!value && lazyPendingPage.value == null) {
+            internalLazyLoading.value = false;
+        }
+    });
+    watch(() => serverSideModel.value, value => {
+        if (value) {
+            clearPlaceholderRows();
+            serverRowModel.reset();
+            serverRowLoadReason.value = autoLazyOnMount.value ? "mount" : "manual";
+            void serverRowModel.fetchBlock(0);
+            return;
+        }
+        clearPlaceholderRows();
+        serverRowModel.reset();
+    }, { immediate: true });
+    onMounted(() => {
+        if (serverSideModel.value) {
+            return;
+        }
+        if (autoLazyOnMount.value && computedHasMore.value && resolvedRows.value.length === 0) {
+            void requestNextPage("mount");
+        }
+    });
+    onBeforeUnmount(() => {
+        if (serverSideModel.value) {
+            serverRowModel.abortAll();
+        }
+        clearPlaceholderRows();
+    });
+    function buildLazyLoadContext(page, reason) {
+        const context = {
+            page,
+            pageSize: resolvedPageSize.value,
+            offset: page * resolvedPageSize.value,
+            totalLoaded: resolvedRows.value.length,
+            reason,
+        };
+        if (serverSideSorting.value) {
+            context.sorts = options.getServerSorts();
+        }
+        if (serverSideFiltering.value) {
+            context.filters = options.getServerFilters();
+        }
+        return context;
+    }
+    async function requestPage(page, reason = "manual") {
+        if (!isLazyMode.value) {
+            if (!loadingState.value && page > lastCompletedPage.value) {
+                options.emit("reach-bottom");
+                options.fireEvent("reachBottom");
+            }
+            return;
+        }
+        if (page < 0) {
+            return;
+        }
+        if (page !== 0 && !computedHasMore.value) {
+            return;
+        }
+        if (internalLazyLoading.value || lazyPendingPage.value != null) {
+            return;
+        }
+        const context = buildLazyLoadContext(page, reason);
+        options.emit("lazy-load", context);
+        options.fireEvent("lazyLoad", context);
+        const loader = options.normalizedProps.value.lazyLoader;
+        if (!loader) {
+            return;
+        }
+        lazyPendingPage.value = page;
+        internalLazyLoading.value = true;
+        lazyErrorState.value = null;
+        try {
+            await loader(context);
+            lastCompletedPage.value = Math.max(lastCompletedPage.value, page);
+            const completionPayload = { ...context };
+            options.emit("lazy-load-complete", completionPayload);
+            options.fireEvent("lazyLoadComplete", completionPayload);
+        }
+        catch (error) {
+            lazyErrorState.value = error;
+            const errorPayload = { ...context, error };
+            options.emit("lazy-load-error", errorPayload);
+            options.fireEvent("lazyLoadError", errorPayload);
+            lazyPendingPage.value = null;
+            internalLazyLoading.value = false;
+            throw error;
+        }
+        finally {
+            if (lazyPendingPage.value != null && lazyPendingPage.value <= lastCompletedPage.value) {
+                lazyPendingPage.value = null;
+            }
+            if (lazyPendingPage.value == null) {
+                internalLazyLoading.value = false;
+            }
+        }
+    }
+    async function requestNextPage(reason = "manual") {
+        const nextPage = Math.max(-1, lastCompletedPage.value) + 1;
+        await requestPage(nextPage, reason);
+    }
+    function resetLazyPaging(options) {
+        lazyPendingPage.value = null;
+        internalLazyLoading.value = false;
+        lazyErrorState.value = null;
+        if (options?.clearRows) {
+            lastCompletedPage.value = -1;
+            lastKnownRowLength.value = 0;
+            return;
+        }
+        const length = resolvedRows.value.length;
+        lastKnownRowLength.value = length;
+        lastCompletedPage.value = Math.max(-1, Math.ceil(length / Math.max(1, resolvedPageSize.value)) - 1);
+    }
+    const lastServerFilterFingerprint = ref(null);
+    const lastServerSortFingerprint = ref(null);
+    let scheduledServerReason = null;
+    let flushServerReloadTask = null;
+    async function reloadServerRowModel(reason) {
+        clearPlaceholderRows();
+        serverRowModel.reset();
+        serverRowLoadReason.value = reason;
+        scrollToTopForServer.value?.();
+        await serverRowModel.fetchBlock(0);
+    }
+    function flushServerReload() {
+        if (!scheduledServerReason)
+            return;
+        if (internalLazyLoading.value || lazyPendingPage.value != null) {
+            return;
+        }
+        const reason = scheduledServerReason;
+        scheduledServerReason = null;
+        flushServerReloadTask = null;
+        if (serverSideModel.value) {
+            void reloadServerRowModel(reason);
+            return;
+        }
+        void triggerServerReload(reason);
+    }
+    function scheduleServerReload(reason) {
+        if (!serverSideModel.value)
+            return;
+        const prioritized = reason === "filter-change";
+        if (!scheduledServerReason || prioritized) {
+            scheduledServerReason = reason;
+        }
+        if (internalLazyLoading.value || lazyPendingPage.value != null) {
+            return;
+        }
+        if (flushServerReloadTask) {
+            return;
+        }
+        flushServerReloadTask = Promise.resolve().then(() => flushServerReload());
+    }
+    async function triggerServerReload(reason) {
+        if (serverSideModel.value) {
+            await reloadServerRowModel(reason);
+            return;
+        }
+        if (!isLazyMode.value)
+            return;
+        resetLazyPaging({ clearRows: true });
+        await requestPage(0, reason);
+    }
+    watch(() => [internalLazyLoading.value, lazyPendingPage.value], () => {
+        if (!internalLazyLoading.value && lazyPendingPage.value == null) {
+            flushServerReload();
+        }
+    });
+    function isServerPlaceholderRow(row) {
+        return Boolean(row && typeof row === "object" && SERVER_PLACEHOLDER_FLAG in row);
+    }
+    function setScrollToTopForServer(fn) {
+        scrollToTopForServer.value = fn;
+    }
+    return {
+        internalLazyLoading,
+        isLazyMode,
+        serverSideModel,
+        serverSideFiltering,
+        serverSideSorting,
+        autoLazyOnScroll,
+        autoLazyOnMount,
+        resolvedRows,
+        loadingState,
+        computedHasMore,
+        requestPage,
+        requestNextPage,
+        resetLazyPaging,
+        triggerServerReload,
+        scheduleServerReload,
+        serverRowModel,
+        serverRowBlocks,
+        serverRowTotal,
+        serverRows,
+        clearPlaceholderRows,
+        isServerPlaceholderRow,
+        lazyPendingPage,
+        lazyErrorState,
+        lastServerFilterFingerprint,
+        lastServerSortFingerprint,
+        setScrollToTopForServer,
+    };
+}

package/dist/composables/useTableEditing.d.ts

@@ -0,0 +1,67 @@
+import type { ComputedRef, Ref } from "vue";
+import type { CellEditEvent, UiTableColumn, VisibleRow } from "../../core/types";
+import type { RowKey } from "@/composables/useSelectableRows";
+import type { HistoryEntry } from "./useTableHistory";
+interface SetCellOptions {
+    collector?: CellEditEvent[];
+    historyCollector?: HistoryEntry[];
+    suppressHistory?: boolean;
+    force?: boolean;
+}
+interface UseTableEditingOptions {
+    processedRows: ComputedRef<VisibleRow[]>;
+    localColumns: Ref<UiTableColumn[]>;
+    emitCellEdit: (event: CellEditEvent) => void;
+    emitBatchEdit: (events: CellEditEvent[]) => void;
+    recordHistory: (entries: HistoryEntry[]) => void;
+    isApplyingHistory: Ref<boolean>;
+    findRowIndexById: (rowId: RowKey) => number | null;
+    getRowIdByIndex: (rowIndex: number) => RowKey | null;
+}
+type RowRef = RowKey | number;
+/**
+ * Determines whether a column can be edited based on its editor configuration.
+ */
+export declare function isColumnEditable(column: UiTableColumn | undefined): boolean;
+/**
+ * Checks if clipboard pastes are allowed for the provided column definition.
+ */
+export declare function canPasteIntoColumn(column: UiTableColumn | undefined): boolean;
+/**
+ * Coordinates edit state, validation, history, and event emission for UiTable cells.
+ */
+export declare function useTableEditing({ processedRows, localColumns, emitCellEdit, emitBatchEdit, recordHistory, isApplyingHistory, findRowIndexById, getRowIdByIndex, }: UseTableEditingOptions): {
+    validationErrors: Record<string, string | null>;
+    getValidationError: (rowIndex: number, colIndex: number) => string | null;
+    setCellValueDirect: (rowRef: RowRef, colIndex: number, value: unknown, options?: SetCellOptions) => boolean;
+    setCellValue: (rowRef: RowRef, column: number | string, value: unknown, options?: {
+        force?: boolean;
+    }) => boolean;
+    setCellValueFromPaste: (rowRef: RowRef, colIndex: number, rawValue: string, options?: SetCellOptions) => boolean;
+    getCellValue: (rowRef: RowRef, column: number | string) => any;
+    getCellRawValue: (rowRef: RowRef, colIndex: number) => any;
+    dispatchEvents: (events: CellEditEvent[]) => void;
+    onCellEdit: (event: CellEditEvent) => void;
+    onCellEditingChange: (editing: boolean) => void;
+    normalizePastedValue: (column: UiTableColumn, row: any, rawValue: string) => any;
+    requestEdit: (rowIndex: number, columnKey: string) => void;
+    isEditingCell: Ref<boolean, boolean>;
+    editCommand: Ref<{
+        rowIndex: number;
+        key: string;
+        token: number;
+    } | null, {
+        rowIndex: number;
+        key: string;
+        token: number;
+    } | {
+        rowIndex: number;
+        key: string;
+        token: number;
+    } | null>;
+    canPasteIntoColumn: typeof canPasteIntoColumn;
+    runValidator: (column: UiTableColumn | undefined, value: unknown, row: any) => string | null;
+    updateValidationState: (rowId: RowKey | null, rowIndex: number, column: UiTableColumn | undefined, value: unknown, row: any) => void;
+};
+export {};
+//# sourceMappingURL=useTableEditing.d.ts.map

package/dist/composables/useTableEditing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTableEditing.d.ts","sourceRoot":"","sources":["../../src/composables/useTableEditing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAgB,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC9F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,UAAU,cAAc;IACtB,SAAS,CAAC,EAAE,aAAa,EAAE,CAAA;IAC3B,gBAAgB,CAAC,EAAE,YAAY,EAAE,CAAA;IACjC,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED,UAAU,sBAAsB;IAC9B,aAAa,EAAE,WAAW,CAAC,UAAU,EAAE,CAAC,CAAA;IACxC,YAAY,EAAE,GAAG,CAAC,aAAa,EAAE,CAAC,CAAA;IAClC,YAAY,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;IAC5C,aAAa,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,IAAI,CAAA;IAChD,aAAa,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,IAAI,CAAA;IAChD,iBAAiB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC/B,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IAClD,eAAe,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;CACrD;AAED,KAAK,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;AAE7B;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS,WAKjE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS,WAMnE;AAUD;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAC9B,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,GAChB,EAAE,sBAAsB;;mCAiDe,MAAM,YAAY,MAAM;iCAsB1B,MAAM,YAAY,MAAM,SAAS,OAAO,YAAW,cAAc;2BAgIvE,MAAM,UAAU,MAAM,GAAG,MAAM,SAAS,OAAO,YAAY;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;oCA3BrE,MAAM,YAAY,MAAM,YAAY,MAAM,YAAY,cAAc;2BAa7E,MAAM,UAAU,MAAM,GAAG,MAAM;8BA9H5B,MAAM,YAAY,MAAM;6BAkEzB,aAAa,EAAE;wBAmFpB,aAAa;mCA4BF,OAAO;mCAtFP,aAAa,OAAO,GAAG,YAAY,MAAM;4BA6FhD,MAAM,aAAa,MAAM;;;kBArOpB,MAAM;aAAO,MAAM;eAAS,MAAM;;kBAAlC,MAAM;aAAO,MAAM;eAAS,MAAM;;kBAAlC,MAAM;aAAO,MAAM;eAAS,MAAM;;;2BAKxC,aAAa,GAAG,SAAS,SAAS,OAAO,OAAO,GAAG;mCAgB3C,MAAM,GAAG,IAAI,YAAY,MAAM,UAAU,aAAa,GAAG,SAAS,SAAS,OAAO,OAAO,GAAG;EA2OnI"}