@affino/datagrid-vue 0.3.2 → 0.3.4

package/dist/composables/useTableColumnBindings.d.ts

@@ -1,25 +0,0 @@
-import { type ComputedRef, type Ref } from "vue";
-import type { UiTableColumn } from "../../core/types";
-import type { HeaderRenderableEntry } from "../../core/types/internal";
-import type { UiTableColumnBinding } from "../context";
-interface UseTableColumnBindingsOptions {
-    headerRenderableEntries: ComputedRef<HeaderRenderableEntry[]>;
-    visibleColumnEntries: ComputedRef<HeaderRenderableEntry[]>;
-    columnTrackStartMap: ComputedRef<Map<string, number>>;
-    localColumns: Ref<UiTableColumn[]>;
-    columnWidthDomMap: ComputedRef<Map<string, number>>;
-    bodyCellClass: (column: UiTableColumn) => string | undefined;
-    isColumnSticky: (column: UiTableColumn) => boolean;
-    getStickySide: (column: UiTableColumn) => "left" | "right" | null;
-    getStickyLeftOffset: (column: UiTableColumn) => number | undefined;
-    getStickyRightOffset: (column: UiTableColumn) => number | undefined;
-    getAriaColIndex: (columnIndex: number) => number;
-}
-export declare function useTableColumnBindings({ headerRenderableEntries, visibleColumnEntries, columnTrackStartMap, localColumns, columnWidthDomMap, bodyCellClass, isColumnSticky, getStickySide, getStickyLeftOffset, getStickyRightOffset, getAriaColIndex, }: UseTableColumnBindingsOptions): {
-    getColumnIndex: (columnKey: string) => number;
-    columnIndexToKey: ComputedRef<Map<number, string>>;
-    bodyColumnBindings: ComputedRef<Map<string, UiTableColumnBinding>>;
-    getBodyColumnBinding: (columnKey: string) => UiTableColumnBinding;
-};
-export {};
-//# sourceMappingURL=useTableColumnBindings.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useTableColumnBindings.d.ts","sourceRoot":"","sources":["../../src/composables/useTableColumnBindings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,WAAW,EAAE,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD,UAAU,6BAA6B;IACrC,uBAAuB,EAAE,WAAW,CAAC,qBAAqB,EAAE,CAAC,CAAA;IAC7D,oBAAoB,EAAE,WAAW,CAAC,qBAAqB,EAAE,CAAC,CAAA;IAC1D,mBAAmB,EAAE,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACrD,YAAY,EAAE,GAAG,CAAC,aAAa,EAAE,CAAC,CAAA;IAClC,iBAAiB,EAAE,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACnD,aAAa,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,MAAM,GAAG,SAAS,CAAA;IAC5D,cAAc,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAA;IAClD,aAAa,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;IACjE,mBAAmB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,MAAM,GAAG,SAAS,CAAA;IAClE,oBAAoB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,MAAM,GAAG,SAAS,CAAA;IACnE,eAAe,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAA;CACjD;AAED,wBAAgB,sBAAsB,CAAC,EACrC,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,eAAe,GAChB,EAAE,6BAA6B;gCAaK,MAAM,KAAG,MAAM;;;sCAgDT,MAAM,KAAG,oBAAoB;EAcvE"}

package/dist/composables/useTableColumnBindings.js

@@ -1,72 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,49 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,411 +0,0 @@
-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,
-    };
-}