@alaarab/ogrid-vue 2.1.3 → 2.1.4

package/dist/esm/composables/useActiveCell.js

@@ -1,77 +0,0 @@
-import { shallowRef, watch, onUnmounted } from 'vue';
-/**
- * Tracks the active cell for keyboard navigation.
- * When wrapperRef and editingCell are provided, scrolls the active cell into view when it changes (and not editing).
- */
-export function useActiveCell(wrapperRef, editingCell) {
-    const activeCell = shallowRef(null);
-    let pendingRaf = 0;
-    // Deduplicating setter — skips update when the cell coordinates haven't actually changed.
-    const setActiveCell = (cell) => {
-        const prev = activeCell.value;
-        if (prev === cell)
-            return;
-        if (prev && cell && prev.rowIndex === cell.rowIndex && prev.columnIndex === cell.columnIndex)
-            return;
-        activeCell.value = cell;
-    };
-    // Scroll active cell into view when it changes (equivalent to useLayoutEffect).
-    // Uses requestAnimationFrame to batch DOM reads (getBoundingClientRect) with the
-    // browser's layout cycle, avoiding forced reflows when rapidly clicking cells.
-    watch([activeCell, () => editingCell?.value], () => {
-        // Cancel any pending scroll from a previous cell change
-        if (pendingRaf) {
-            cancelAnimationFrame(pendingRaf);
-            pendingRaf = 0;
-        }
-        if (activeCell.value == null ||
-            !wrapperRef?.value ||
-            editingCell?.value != null)
-            return;
-        // Capture the target coordinates before the async boundary
-        const { rowIndex, columnIndex } = activeCell.value;
-        pendingRaf = requestAnimationFrame(() => {
-            pendingRaf = 0;
-            const wrapper = wrapperRef.value;
-            if (!wrapper)
-                return;
-            // Verify the active cell hasn't changed since we scheduled
-            const current = activeCell.value;
-            if (!current || current.rowIndex !== rowIndex || current.columnIndex !== columnIndex)
-                return;
-            const selector = `[data-row-index="${rowIndex}"][data-col-index="${columnIndex}"]`;
-            const cell = wrapper.querySelector(selector);
-            if (cell) {
-                const thead = wrapper.querySelector('thead');
-                const headerHeight = thead ? thead.getBoundingClientRect().height : 0;
-                const wrapperRect = wrapper.getBoundingClientRect();
-                const cellRect = cell.getBoundingClientRect();
-                // Vertical scroll (account for sticky thead)
-                const visibleTop = wrapperRect.top + headerHeight;
-                if (cellRect.top < visibleTop) {
-                    wrapper.scrollTop -= visibleTop - cellRect.top;
-                }
-                else if (cellRect.bottom > wrapperRect.bottom) {
-                    wrapper.scrollTop += cellRect.bottom - wrapperRect.bottom;
-                }
-                // Horizontal scroll
-                if (cellRect.left < wrapperRect.left) {
-                    wrapper.scrollLeft -= wrapperRect.left - cellRect.left;
-                }
-                else if (cellRect.right > wrapperRect.right) {
-                    wrapper.scrollLeft += cellRect.right - wrapperRect.right;
-                }
-                if (document.activeElement !== cell && typeof cell.focus === 'function') {
-                    cell.focus({ preventScroll: true });
-                }
-            }
-        });
-    }, { flush: 'post' });
-    onUnmounted(() => {
-        if (pendingRaf) {
-            cancelAnimationFrame(pendingRaf);
-            pendingRaf = 0;
-        }
-    });
-    return { activeCell, setActiveCell };
-}

package/dist/esm/composables/useCellEditing.js

@@ -1,27 +0,0 @@
-import { shallowRef, ref } from 'vue';
-/**
- * Manages cell editing state: which cell is being edited and its pending value.
- * Optionally scrolls to the cell's row before opening the editor when virtual scrolling is active.
- */
-export function useCellEditing(params) {
-    const editingCell = shallowRef(null);
-    const pendingEditorValue = ref(undefined);
-    const setEditingCell = (cell) => {
-        if (cell && params?.scrollToRow && params?.getRowIndex) {
-            const rowIndex = params.getRowIndex(cell.rowId);
-            if (rowIndex >= 0) {
-                params.scrollToRow(rowIndex, 'center');
-            }
-        }
-        editingCell.value = cell;
-    };
-    const setPendingEditorValue = (value) => {
-        pendingEditorValue.value = value;
-    };
-    return {
-        editingCell,
-        setEditingCell,
-        pendingEditorValue,
-        setPendingEditorValue,
-    };
-}

package/dist/esm/composables/useCellSelection.js

@@ -1,359 +0,0 @@
-import { shallowRef, ref, isRef, onMounted, onUnmounted } from 'vue';
-import { normalizeSelectionRange, rangesEqual, computeAutoScrollSpeed } from '@alaarab/ogrid-core';
-import { useLatestRef } from './useLatestRef';
-/** DOM attribute names used for drag-range highlighting (bypasses Vue). */
-const DRAG_ATTR = 'data-drag-range';
-const DRAG_ANCHOR_ATTR = 'data-drag-anchor';
-/** Auto-scroll config */
-const AUTO_SCROLL_EDGE = 40;
-const AUTO_SCROLL_INTERVAL = 16;
-/**
- * Manages cell selection range with drag-to-select and select-all support.
- */
-export function useCellSelection(params) {
-    // Store latest params in a ref for stable handler references
-    const paramsRef = useLatestRef(params);
-    const { wrapperRef, setActiveCell } = params; // These are stable, safe to destructure
-    const getColOffset = () => isRef(params.colOffset) ? params.colOffset.value : params.colOffset;
-    const selectionRange = shallowRef(null);
-    const isDragging = ref(false); // boolean primitive, ref is fine
-    const isDraggingInternal = ref(false); // ref so event handlers always read current value
-    const isUnmounted = ref(false); // ref for clean unmount tracking
-    let dragMoved = false;
-    let dragStart = null;
-    let rafId = 0;
-    let liveDragRange = null;
-    let autoScrollInterval = null;
-    let lastMousePos = null;
-    const setSelectionRange = (next) => {
-        if (rangesEqual(selectionRange.value, next))
-            return;
-        selectionRange.value = next;
-    };
-    const handleCellMouseDown = (e, rowIndex, globalColIndex) => {
-        if (e.button !== 0)
-            return;
-        const colOffset = getColOffset();
-        if (globalColIndex < colOffset)
-            return;
-        e.preventDefault();
-        const dataColIndex = globalColIndex - colOffset;
-        const currentRange = selectionRange.value;
-        if (e.shiftKey && currentRange != null) {
-            setSelectionRange(normalizeSelectionRange({
-                startRow: currentRange.startRow,
-                startCol: currentRange.startCol,
-                endRow: rowIndex,
-                endCol: dataColIndex,
-            }));
-            setActiveCell({ rowIndex, columnIndex: globalColIndex });
-        }
-        else {
-            dragStart = { row: rowIndex, col: dataColIndex };
-            dragMoved = false;
-            const initial = {
-                startRow: rowIndex,
-                startCol: dataColIndex,
-                endRow: rowIndex,
-                endCol: dataColIndex,
-            };
-            setSelectionRange(initial);
-            liveDragRange = initial;
-            setActiveCell({ rowIndex, columnIndex: globalColIndex });
-            isDraggingInternal.value = true;
-            // Apply drag attrs immediately for the initial cell so the anchor styling shows
-            // even before the first mousemove. This ensures instant visual feedback.
-            setTimeout(() => applyDragAttrs(initial), 0);
-        }
-    };
-    const handleSelectAllCells = () => {
-        const { rowCount, visibleColCount } = paramsRef.value;
-        if (rowCount.value === 0 || visibleColCount.value === 0)
-            return;
-        setSelectionRange({
-            startRow: 0,
-            startCol: 0,
-            endRow: rowCount.value - 1,
-            endCol: visibleColCount.value - 1,
-        });
-        setActiveCell({ rowIndex: 0, columnIndex: getColOffset() });
-    };
-    // --- Window mouse move/up for drag selection ---
-    /** Set of currently drag-marked HTMLElements — avoids O(n) full DOM scan on each frame. */
-    const markedCells = new Set();
-    /** Cell lookup index built on drag start — O(1) lookups per frame instead of querySelectorAll. */
-    let cellIndex = null;
-    /** Build cell lookup index from a single querySelectorAll scan. */
-    const buildCellIndex = () => {
-        const wrapper = wrapperRef.value;
-        if (!wrapper)
-            return;
-        cellIndex = new Map();
-        const cells = wrapper.querySelectorAll('[data-row-index][data-col-index]');
-        for (let i = 0; i < cells.length; i++) {
-            const el = cells[i];
-            const r = el.getAttribute('data-row-index') ?? '';
-            const c = el.getAttribute('data-col-index') ?? '';
-            cellIndex.set(`${r},${c}`, el);
-        }
-    };
-    /** Apply styling to a single in-range cell (attrs + box-shadow). */
-    const styleCellInRange = (el, r, c, minR, maxR, minC, maxC, anchor) => {
-        if (!el.hasAttribute(DRAG_ATTR))
-            el.setAttribute(DRAG_ATTR, '');
-        const isAnchor = anchor && r === anchor.row && c === anchor.col;
-        if (isAnchor) {
-            if (!el.hasAttribute(DRAG_ANCHOR_ATTR))
-                el.setAttribute(DRAG_ANCHOR_ATTR, '');
-        }
-        else {
-            if (el.hasAttribute(DRAG_ANCHOR_ATTR))
-                el.removeAttribute(DRAG_ANCHOR_ATTR);
-        }
-        const shadows = [];
-        if (r === minR)
-            shadows.push('inset 0 2px 0 0 var(--ogrid-selection, #217346)');
-        if (r === maxR)
-            shadows.push('inset 0 -2px 0 0 var(--ogrid-selection, #217346)');
-        if (c === minC)
-            shadows.push('inset 2px 0 0 0 var(--ogrid-selection, #217346)');
-        if (c === maxC)
-            shadows.push('inset -2px 0 0 0 var(--ogrid-selection, #217346)');
-        el.style.boxShadow = shadows.length > 0 ? shadows.join(', ') : '';
-        markedCells.add(el);
-    };
-    /** Remove drag styling from a single cell. */
-    const unstyleCell = (el) => {
-        el.removeAttribute(DRAG_ATTR);
-        el.removeAttribute(DRAG_ANCHOR_ATTR);
-        el.style.boxShadow = '';
-    };
-    /** Toggle DRAG_ATTR on cells to show the range highlight via CSS.
-     *  Uses a cell index Map for O(1) lookups per cell in the range instead of scanning all cells.
-     *  Also sets edge box-shadows for a green border around the selection range,
-     *  and marks the anchor cell with DRAG_ANCHOR_ATTR (white background). */
-    const applyDragAttrs = (range) => {
-        const wrapper = wrapperRef.value;
-        if (!wrapper)
-            return;
-        const minR = Math.min(range.startRow, range.endRow);
-        const maxR = Math.max(range.startRow, range.endRow);
-        const minC = Math.min(range.startCol, range.endCol);
-        const maxC = Math.max(range.startCol, range.endCol);
-        const anchor = dragStart;
-        const colOff = getColOffset();
-        // 1. Un-mark cells that are no longer in the new range (iterate the small set, not all DOM)
-        for (const el of markedCells) {
-            const r = parseInt(el.getAttribute('data-row-index') ?? '', 10);
-            const c = parseInt(el.getAttribute('data-col-index') ?? '', 10) - colOff;
-            const stillInRange = r >= minR && r <= maxR && c >= minC && c <= maxC;
-            if (!stillInRange) {
-                unstyleCell(el);
-                markedCells.delete(el);
-            }
-        }
-        // Build index on first call if not yet initialized
-        if (!cellIndex)
-            buildCellIndex();
-        // 2. Look up only the cells in the new range — O(range size) via Map lookup.
-        for (let r = minR; r <= maxR; r++) {
-            for (let c = minC; c <= maxC; c++) {
-                const key = `${r},${c + colOff}`;
-                let el = cellIndex?.get(key);
-                // Handle virtual scroll recycling — if element is stale, rebuild index once
-                if (el && !el.isConnected) {
-                    buildCellIndex();
-                    el = cellIndex?.get(key);
-                }
-                if (el) {
-                    styleCellInRange(el, r, c, minR, maxR, minC, maxC, anchor);
-                }
-            }
-        }
-    };
-    /** Clear all drag styling using the tracked set — O(marked) not O(all cells). */
-    const clearDragAttrs = () => {
-        for (const el of markedCells) {
-            unstyleCell(el);
-        }
-        markedCells.clear();
-        cellIndex = null;
-    };
-    const resolveRange = (cx, cy) => {
-        if (!dragStart)
-            return null;
-        const target = document.elementFromPoint(cx, cy);
-        const cell = target?.closest?.('[data-row-index][data-col-index]');
-        if (!cell)
-            return null;
-        const r = parseInt(cell.getAttribute('data-row-index') ?? '', 10);
-        const c = parseInt(cell.getAttribute('data-col-index') ?? '', 10);
-        const colOffset = getColOffset();
-        if (Number.isNaN(r) || Number.isNaN(c) || c < colOffset)
-            return null;
-        const dataCol = c - colOffset;
-        return normalizeSelectionRange({
-            startRow: dragStart.row,
-            startCol: dragStart.col,
-            endRow: r,
-            endCol: dataCol,
-        });
-    };
-    const stopAutoScroll = () => {
-        if (autoScrollInterval) {
-            clearInterval(autoScrollInterval);
-            autoScrollInterval = null;
-        }
-    };
-    const updateAutoScroll = () => {
-        const wrapper = wrapperRef.value;
-        if (!wrapper || !lastMousePos || !isDraggingInternal.value) {
-            stopAutoScroll();
-            return;
-        }
-        const rect = wrapper.getBoundingClientRect();
-        let dx = 0;
-        let dy = 0;
-        if (lastMousePos.cy < rect.top + AUTO_SCROLL_EDGE) {
-            dy = -computeAutoScrollSpeed(rect.top + AUTO_SCROLL_EDGE - lastMousePos.cy);
-        }
-        else if (lastMousePos.cy > rect.bottom - AUTO_SCROLL_EDGE) {
-            dy = computeAutoScrollSpeed(lastMousePos.cy - (rect.bottom - AUTO_SCROLL_EDGE));
-        }
-        if (lastMousePos.cx < rect.left + AUTO_SCROLL_EDGE) {
-            dx = -computeAutoScrollSpeed(rect.left + AUTO_SCROLL_EDGE - lastMousePos.cx);
-        }
-        else if (lastMousePos.cx > rect.right - AUTO_SCROLL_EDGE) {
-            dx = computeAutoScrollSpeed(lastMousePos.cx - (rect.right - AUTO_SCROLL_EDGE));
-        }
-        if (dx === 0 && dy === 0) {
-            stopAutoScroll();
-            return;
-        }
-        if (!autoScrollInterval) {
-            autoScrollInterval = setInterval(() => {
-                const w = wrapperRef.value;
-                const p = lastMousePos;
-                if (!w || !p || !isDraggingInternal.value) {
-                    stopAutoScroll();
-                    return;
-                }
-                const r = w.getBoundingClientRect();
-                let sdx = 0;
-                let sdy = 0;
-                if (p.cy < r.top + AUTO_SCROLL_EDGE)
-                    sdy = -computeAutoScrollSpeed(r.top + AUTO_SCROLL_EDGE - p.cy);
-                else if (p.cy > r.bottom - AUTO_SCROLL_EDGE)
-                    sdy = computeAutoScrollSpeed(p.cy - (r.bottom - AUTO_SCROLL_EDGE));
-                if (p.cx < r.left + AUTO_SCROLL_EDGE)
-                    sdx = -computeAutoScrollSpeed(r.left + AUTO_SCROLL_EDGE - p.cx);
-                else if (p.cx > r.right - AUTO_SCROLL_EDGE)
-                    sdx = computeAutoScrollSpeed(p.cx - (r.right - AUTO_SCROLL_EDGE));
-                if (sdx === 0 && sdy === 0) {
-                    stopAutoScroll();
-                    return;
-                }
-                w.scrollTop += sdy;
-                w.scrollLeft += sdx;
-                const newRange = resolveRange(p.cx, p.cy);
-                if (newRange) {
-                    liveDragRange = newRange;
-                    applyDragAttrs(newRange);
-                }
-            }, AUTO_SCROLL_INTERVAL);
-        }
-    };
-    const onMove = (e) => {
-        if (!isDraggingInternal.value || !dragStart)
-            return;
-        if (!dragMoved) {
-            dragMoved = true;
-            isDragging.value = true;
-            // Build cell index once at drag start for O(1) lookups during drag
-            buildCellIndex();
-        }
-        lastMousePos = { cx: e.clientX, cy: e.clientY };
-        updateAutoScroll();
-        if (rafId)
-            cancelAnimationFrame(rafId);
-        rafId = requestAnimationFrame(() => {
-            rafId = 0;
-            if (!lastMousePos)
-                return;
-            const newRange = resolveRange(lastMousePos.cx, lastMousePos.cy);
-            if (!newRange)
-                return;
-            const prev = liveDragRange;
-            if (prev &&
-                prev.startRow === newRange.startRow &&
-                prev.startCol === newRange.startCol &&
-                prev.endRow === newRange.endRow &&
-                prev.endCol === newRange.endCol) {
-                return;
-            }
-            liveDragRange = newRange;
-            applyDragAttrs(newRange);
-        });
-    };
-    const onUp = () => {
-        if (!isDraggingInternal.value)
-            return;
-        stopAutoScroll();
-        if (rafId) {
-            cancelAnimationFrame(rafId);
-            rafId = 0;
-        }
-        isDraggingInternal.value = false;
-        const wasDrag = dragMoved;
-        if (wasDrag) {
-            if (lastMousePos) {
-                const flushed = resolveRange(lastMousePos.cx, lastMousePos.cy);
-                if (flushed)
-                    liveDragRange = flushed;
-            }
-            const finalRange = liveDragRange;
-            if (finalRange) {
-                setSelectionRange(finalRange);
-                setActiveCell({
-                    rowIndex: finalRange.endRow,
-                    columnIndex: finalRange.endCol + getColOffset(),
-                });
-            }
-        }
-        clearDragAttrs();
-        liveDragRange = null;
-        lastMousePos = null;
-        dragStart = null;
-        if (wasDrag)
-            isDragging.value = false;
-    };
-    const onMoveSafe = (e) => {
-        if (isUnmounted.value)
-            return;
-        onMove(e);
-    };
-    const onUpSafe = () => {
-        if (isUnmounted.value)
-            return;
-        onUp();
-    };
-    onMounted(() => {
-        window.addEventListener('mousemove', onMoveSafe, true);
-        window.addEventListener('mouseup', onUpSafe, true);
-    });
-    onUnmounted(() => {
-        isUnmounted.value = true;
-        window.removeEventListener('mousemove', onMoveSafe, true);
-        window.removeEventListener('mouseup', onUpSafe, true);
-        if (rafId)
-            cancelAnimationFrame(rafId);
-        stopAutoScroll();
-    });
-    return {
-        selectionRange,
-        setSelectionRange,
-        handleCellMouseDown,
-        handleSelectAllCells,
-        isDragging,
-    };
-}

package/dist/esm/composables/useClipboard.js

@@ -1,87 +0,0 @@
-import { ref, shallowRef, isRef } from 'vue';
-import { normalizeSelectionRange, formatSelectionAsTsv, parseTsvClipboard, applyPastedValues, applyCutClear } from '@alaarab/ogrid-core';
-/**
- * Manages copy, cut, and paste operations for cell ranges with TSV clipboard format.
- */
-export function useClipboard(params) {
-    const { items, visibleCols, selectionRange, activeCell, editable, onCellValueChanged, beginBatch, endBatch, } = params;
-    const getColOffset = () => isRef(params.colOffset) ? params.colOffset.value : params.colOffset;
-    const cutRange = shallowRef(null);
-    const copyRange = shallowRef(null);
-    const internalClipboardRef = ref(null);
-    const getEffectiveRange = () => {
-        const sel = selectionRange.value;
-        const ac = activeCell.value;
-        const colOffset = getColOffset();
-        return sel ?? (ac != null
-            ? { startRow: ac.rowIndex, startCol: ac.columnIndex - colOffset, endRow: ac.rowIndex, endCol: ac.columnIndex - colOffset }
-            : null);
-    };
-    const handleCopy = () => {
-        const range = getEffectiveRange();
-        if (range == null)
-            return;
-        const norm = normalizeSelectionRange(range);
-        const tsv = formatSelectionAsTsv(items.value, visibleCols.value, norm);
-        internalClipboardRef.value = tsv;
-        copyRange.value = norm;
-        void navigator.clipboard.writeText(tsv).catch((err) => {
-            if (typeof console !== 'undefined')
-                console.warn('[OGrid] Clipboard write failed:', err);
-        });
-    };
-    const handleCut = () => {
-        if (editable.value === false)
-            return;
-        const range = getEffectiveRange();
-        if (range == null || onCellValueChanged.value == null)
-            return;
-        const norm = normalizeSelectionRange(range);
-        cutRange.value = norm;
-        copyRange.value = null;
-        handleCopy();
-        copyRange.value = null;
-    };
-    const handlePaste = async () => {
-        if (editable.value === false)
-            return;
-        const callback = onCellValueChanged.value;
-        if (callback == null)
-            return;
-        let text;
-        try {
-            text = await navigator.clipboard.readText();
-        }
-        catch {
-            text = '';
-        }
-        if (!text.trim() && internalClipboardRef.value != null) {
-            text = internalClipboardRef.value;
-        }
-        if (!text.trim())
-            return;
-        const norm = getEffectiveRange();
-        const anchorRow = norm ? norm.startRow : 0;
-        const anchorCol = norm ? norm.startCol : 0;
-        const currentItems = items.value;
-        const currentCols = visibleCols.value;
-        const parsedRows = parseTsvClipboard(text);
-        beginBatch?.();
-        const pasteEvents = applyPastedValues(parsedRows, anchorRow, anchorCol, currentItems, currentCols);
-        for (const evt of pasteEvents)
-            callback(evt);
-        if (cutRange.value) {
-            const cutEvents = applyCutClear(cutRange.value, currentItems, currentCols);
-            for (const evt of cutEvents)
-                callback(evt);
-            cutRange.value = null;
-        }
-        endBatch?.();
-        copyRange.value = null;
-    };
-    const clearClipboardRanges = () => {
-        copyRange.value = null;
-        cutRange.value = null;
-    };
-    return { handleCopy, handleCut, handlePaste, cutRange, copyRange, clearClipboardRanges };
-}

package/dist/esm/composables/useColumnChooserState.js

@@ -1,74 +0,0 @@
-import { ref, computed, watch, onUnmounted } from 'vue';
-/**
- * Returns open/setOpen, handleToggle, handleClose, handleCheckboxChange, handleSelectAll, handleClearAll.
- */
-export function useColumnChooserState(params) {
-    const { columns, visibleColumns, onVisibilityChange } = params;
-    const open = ref(false);
-    let keyDownHandler = null;
-    const setupEscapeHandler = () => {
-        cleanupEscapeHandler();
-        keyDownHandler = (event) => {
-            if (event.key === 'Escape') {
-                event.preventDefault();
-                open.value = false;
-            }
-        };
-        document.addEventListener('keydown', keyDownHandler, true);
-    };
-    const cleanupEscapeHandler = () => {
-        if (keyDownHandler) {
-            document.removeEventListener('keydown', keyDownHandler, true);
-            keyDownHandler = null;
-        }
-    };
-    watch(open, (isOpen) => {
-        if (isOpen)
-            setupEscapeHandler();
-        else
-            cleanupEscapeHandler();
-    });
-    onUnmounted(() => cleanupEscapeHandler());
-    const setOpen = (value) => {
-        open.value = value;
-    };
-    const handleToggle = () => {
-        open.value = !open.value;
-    };
-    const handleClose = () => {
-        open.value = false;
-    };
-    const handleCheckboxChange = (columnKey) => {
-        return (visible) => {
-            onVisibilityChange(columnKey, visible);
-        };
-    };
-    const handleSelectAll = () => {
-        columns.value.forEach((col) => {
-            if (!visibleColumns.value.has(col.columnId)) {
-                onVisibilityChange(col.columnId, true);
-            }
-        });
-    };
-    const handleClearAll = () => {
-        // Required columns are silently skipped — no feedback is provided to the user
-        columns.value.forEach((col) => {
-            if (!col.required && visibleColumns.value.has(col.columnId)) {
-                onVisibilityChange(col.columnId, false);
-            }
-        });
-    };
-    const visibleCount = computed(() => visibleColumns.value.size);
-    const totalCount = computed(() => columns.value.length);
-    return {
-        open,
-        setOpen,
-        handleToggle,
-        handleClose,
-        handleCheckboxChange,
-        handleSelectAll,
-        handleClearAll,
-        visibleCount,
-        totalCount,
-    };
-}