@alaarab/ogrid-core 2.1.2 → 2.1.4

package/dist/esm/utils/gridRowComparator.js

@@ -1,78 +0,0 @@
-/**
- * Checks whether a given row index falls within a selection range.
- * O(1) — used by React.memo comparators to skip unchanged rows.
- */
-export function isRowInRange(range, rowIndex) {
-    if (!range)
-        return false;
-    const minR = Math.min(range.startRow, range.endRow);
-    const maxR = Math.max(range.startRow, range.endRow);
-    return rowIndex >= minR && rowIndex <= maxR;
-}
-/**
- * Shared React.memo comparator for GridRow components across all 3 UI packages.
- * Skips re-render for rows unaffected by selection/editing/interaction changes.
- *
- * Used by:
- * - packages/radix/src/DataGridTable/DataGridTable.tsx
- * - packages/fluent/src/DataGridTable/DataGridTable.tsx
- * - packages/material/src/DataGridTable/DataGridTable.tsx
- */
-export function areGridRowPropsEqual(prev, next) {
-    // Data / structure changes — always re-render
-    if (prev.item !== next.item)
-        return false;
-    if (prev.isSelected !== next.isSelected)
-        return false;
-    if (prev.hasCheckboxCol !== next.hasCheckboxCol)
-        return false;
-    // Framework-specific structure props (compared by identity)
-    if (prev.visibleCols !== next.visibleCols)
-        return false;
-    if (prev.columnMeta !== next.columnMeta)
-        return false;
-    if (prev.cellClassMap !== next.cellClassMap)
-        return false;
-    if (prev.columnLayouts !== next.columnLayouts)
-        return false;
-    const ri = prev.rowIndex;
-    // Editing cell in this row?
-    if (prev.editingRowId !== next.editingRowId) {
-        if (prev.editingRowId === prev.rowId || next.editingRowId === next.rowId)
-            return false;
-    }
-    // Active cell in this row?
-    const prevActive = prev.activeCell?.rowIndex === ri;
-    const nextActive = next.activeCell?.rowIndex === ri;
-    if (prevActive !== nextActive)
-        return false;
-    if (prevActive && nextActive && prev.activeCell?.columnIndex !== next.activeCell?.columnIndex)
-        return false;
-    // Selection range touches this row?
-    const prevInSel = isRowInRange(prev.selectionRange, ri);
-    const nextInSel = isRowInRange(next.selectionRange, ri);
-    if (prevInSel !== nextInSel)
-        return false;
-    if (prevInSel && nextInSel) {
-        if (prev.selectionRange?.startCol !== next.selectionRange?.startCol ||
-            prev.selectionRange?.endCol !== next.selectionRange?.endCol)
-            return false;
-    }
-    // Fill handle (selection end row) + isDragging
-    const prevIsEnd = prev.selectionRange?.endRow === ri;
-    const nextIsEnd = next.selectionRange?.endRow === ri;
-    if (prevIsEnd !== nextIsEnd)
-        return false;
-    if ((prevIsEnd || nextIsEnd) && prev.isDragging !== next.isDragging)
-        return false;
-    // Cut/copy ranges touch this row?
-    if (prev.cutRange !== next.cutRange) {
-        if (isRowInRange(prev.cutRange, ri) || isRowInRange(next.cutRange, ri))
-            return false;
-    }
-    if (prev.copyRange !== next.copyRange) {
-        if (isRowInRange(prev.copyRange, ri) || isRowInRange(next.copyRange, ri))
-            return false;
-    }
-    return true;
-}

package/dist/esm/utils/index.js

@@ -1,25 +0,0 @@
-export { escapeCsvValue, buildCsvHeader, buildCsvRows, exportToCsv, triggerCsvDownload, } from './exportToCsv';
-export { getCellValue } from './cellValue';
-export { flattenColumns, buildHeaderRows } from './columnUtils';
-export { isFilterConfig, getFilterField, mergeFilter, deriveFilterOptionsFromData, getMultiSelectFilterFields, } from './ogridHelpers';
-export { getStatusBarParts } from './statusBarHelpers';
-export { getDataGridStatusBarConfig } from './dataGridStatusBar';
-export { getPaginationViewModel, PAGE_SIZE_OPTIONS, MAX_PAGE_BUTTONS, } from './paginationHelpers';
-export { GRID_CONTEXT_MENU_ITEMS, COLUMN_HEADER_MENU_ITEMS, getContextMenuHandlers, getColumnHeaderMenuItems, formatShortcut } from './gridContextMenuHelpers';
-export { parseValue, numberParser, currencyParser, dateParser, emailParser, booleanParser, } from './valueParsers';
-export { computeAggregations } from './aggregationUtils';
-export { processClientSideData } from './clientSideData';
-export { areGridRowPropsEqual, isRowInRange } from './gridRowComparator';
-export { getPinStateForColumn, reorderColumnArray, calculateDropTarget, } from './columnReorder';
-export { computeVisibleRange, computeTotalHeight, getScrollTopForRow, } from './virtualScroll';
-export { getHeaderFilterConfig, getCellRenderDescriptor, resolveCellDisplayContent, resolveCellStyle, buildInlineEditorProps, buildPopoverEditorProps, } from './dataGridViewModel';
-export { debounce } from './debounce';
-export { measureRange, injectGlobalStyles } from './dom';
-export { computeNextSortState } from './sortHelpers';
-export { measureColumnContentWidth, AUTOSIZE_EXTRA_PX, AUTOSIZE_MAX_PX } from './columnAutosize';
-export { findCtrlArrowTarget, computeTabNavigation, computeArrowNavigation, applyCellDeletion } from './keyboardNavigation';
-export { rangesEqual, clampSelectionToBounds, computeAutoScrollSpeed, applyRangeRowSelection, computeRowSelectionState } from './selectionHelpers';
-export { formatCellValueForTsv, formatSelectionAsTsv, parseTsvClipboard, applyPastedValues, applyCutClear, } from './clipboardHelpers';
-export { applyFillValues } from './fillHelpers';
-export { UndoRedoStack } from './undoRedoStack';
-export { validateColumns, validateRowIds } from './validation';

package/dist/esm/utils/keyboardNavigation.js

@@ -1,181 +0,0 @@
-import { normalizeSelectionRange } from '../types/dataGridTypes';
-import { getCellValue } from './cellValue';
-import { parseValue } from './valueParsers';
-/**
- * Excel-style Ctrl+Arrow: find the target position along a 1D axis.
- * - Non-empty current + non-empty next → scan through non-empties, stop at last before empty/edge.
- * - Otherwise → skip empties, land on next non-empty or edge.
- *
- * @param pos   Current position (row or column index).
- * @param edge  The boundary position (0 for backward, max for forward).
- * @param step  Direction: +1 (forward) or -1 (backward).
- * @param isEmpty  Predicate: returns true if the cell at this index is empty.
- * @returns     The target position after the jump.
- */
-export function findCtrlArrowTarget(pos, edge, step, isEmpty) {
-    if (pos === edge)
-        return pos;
-    const next = pos + step;
-    if (!isEmpty(pos) && !isEmpty(next)) {
-        // Scan forward through non-empties; stop at the last before an empty or edge
-        let p = next;
-        while (p !== edge) {
-            if (isEmpty(p + step))
-                return p;
-            p += step;
-        }
-        return edge;
-    }
-    // Skip empties; land on first non-empty or edge
-    let p = next;
-    while (p !== edge) {
-        if (!isEmpty(p))
-            return p;
-        p += step;
-    }
-    return edge;
-}
-/**
- * Compute the new Tab navigation position given the current position and direction.
- *
- * @param rowIndex      Current row index.
- * @param columnIndex   Current absolute column index (includes checkbox offset).
- * @param maxRowIndex   Maximum row index (items.length - 1). Must be >= 0.
- * @param maxColIndex   Maximum absolute column index. Must be >= 0.
- * @param colOffset     Number of non-data leading columns (checkbox column offset).
- * @param shiftKey      True if Shift is held (backward tab).
- * @returns New { rowIndex, columnIndex } after tab. Caller must ensure maxRowIndex and maxColIndex are non-negative.
- */
-export function computeTabNavigation(rowIndex, columnIndex, maxRowIndex, maxColIndex, colOffset, shiftKey) {
-    let newRow = rowIndex;
-    let newCol = columnIndex;
-    if (shiftKey) {
-        if (columnIndex > colOffset) {
-            newCol = columnIndex - 1;
-        }
-        else if (rowIndex > 0) {
-            newRow = rowIndex - 1;
-            newCol = maxColIndex;
-        }
-    }
-    else {
-        if (columnIndex < maxColIndex) {
-            newCol = columnIndex + 1;
-        }
-        else if (rowIndex < maxRowIndex) {
-            newRow = rowIndex + 1;
-            newCol = colOffset;
-        }
-    }
-    return { rowIndex: newRow, columnIndex: newCol };
-}
-/**
- * Computes the next active cell position and selection range for a single arrow key press.
- * Handles Ctrl+Arrow (jump to edge), Shift+Arrow (extend selection), and plain Arrow (move).
- *
- * Pure function — no framework dependencies.
- *
- * @param ctx  Arrow navigation context with current position, direction, modifiers, and grid bounds.
- * @returns The new row/column indices and selection range.
- */
-export function computeArrowNavigation(ctx) {
-    const { direction, rowIndex, columnIndex, dataColIndex, colOffset, maxRowIndex, maxColIndex, visibleColCount, isCtrl, isShift, selectionRange, isEmptyAt, } = ctx;
-    let newRowIndex = rowIndex;
-    let newColumnIndex = columnIndex;
-    if (direction === 'ArrowDown') {
-        newRowIndex = isCtrl
-            ? findCtrlArrowTarget(rowIndex, maxRowIndex, 1, (r) => isEmptyAt(r, Math.max(0, dataColIndex)))
-            : Math.min(rowIndex + 1, maxRowIndex);
-    }
-    else if (direction === 'ArrowUp') {
-        newRowIndex = isCtrl
-            ? findCtrlArrowTarget(rowIndex, 0, -1, (r) => isEmptyAt(r, Math.max(0, dataColIndex)))
-            : Math.max(rowIndex - 1, 0);
-    }
-    else if (direction === 'ArrowRight') {
-        if (isCtrl && dataColIndex >= 0) {
-            newColumnIndex = findCtrlArrowTarget(dataColIndex, visibleColCount - 1, 1, (c) => isEmptyAt(rowIndex, c)) + colOffset;
-        }
-        else {
-            newColumnIndex = Math.min(columnIndex + 1, maxColIndex);
-        }
-    }
-    else { // ArrowLeft
-        if (isCtrl && dataColIndex >= 0) {
-            newColumnIndex = findCtrlArrowTarget(dataColIndex, 0, -1, (c) => isEmptyAt(rowIndex, c)) + colOffset;
-        }
-        else {
-            newColumnIndex = Math.max(columnIndex - 1, colOffset);
-        }
-    }
-    const newDataColIndex = newColumnIndex - colOffset;
-    const isVertical = direction === 'ArrowDown' || direction === 'ArrowUp';
-    let newRange;
-    if (isShift) {
-        if (isVertical) {
-            newRange = normalizeSelectionRange({
-                startRow: selectionRange?.startRow ?? rowIndex,
-                startCol: selectionRange?.startCol ?? dataColIndex,
-                endRow: newRowIndex,
-                endCol: selectionRange?.endCol ?? dataColIndex,
-            });
-        }
-        else {
-            newRange = normalizeSelectionRange({
-                startRow: selectionRange?.startRow ?? rowIndex,
-                startCol: selectionRange?.startCol ?? dataColIndex,
-                endRow: selectionRange?.endRow ?? rowIndex,
-                endCol: newDataColIndex,
-            });
-        }
-    }
-    else {
-        newRange = {
-            startRow: newRowIndex,
-            startCol: newDataColIndex,
-            endRow: newRowIndex,
-            endCol: newDataColIndex,
-        };
-    }
-    return { newRowIndex, newColumnIndex, newDataColIndex, newRange };
-}
-/**
- * Apply cell deletion (Delete/Backspace key) across a selection range.
- * For each editable cell in the range, parses an empty string as the new value
- * and emits a cell value changed event.
- *
- * Pure function — no framework dependencies.
- *
- * @param range       The normalized selection range to clear.
- * @param items       Array of all row data objects.
- * @param visibleCols Visible column definitions.
- * @returns Array of cell value changed events to apply.
- */
-export function applyCellDeletion(range, items, visibleCols) {
-    const norm = normalizeSelectionRange(range);
-    const events = [];
-    for (let r = norm.startRow; r <= norm.endRow; r++) {
-        for (let c = norm.startCol; c <= norm.endCol; c++) {
-            if (r >= items.length || c >= visibleCols.length)
-                continue;
-            const item = items[r];
-            const col = visibleCols[c];
-            const colEditable = col.editable === true ||
-                (typeof col.editable === 'function' && col.editable(item));
-            if (!colEditable)
-                continue;
-            const oldValue = getCellValue(item, col);
-            const result = parseValue('', oldValue, item, col);
-            if (!result.valid)
-                continue;
-            events.push({
-                item,
-                columnId: col.columnId,
-                oldValue,
-                newValue: result.value,
-                rowIndex: r,
-            });
-        }
-    }
-    return events;
-}

package/dist/esm/utils/ogridHelpers.js

@@ -1,67 +0,0 @@
-import { getCellValue } from './cellValue';
-/** Type guard: returns true if val is an IColumnFilterDef (an object with a filter type). */
-export function isFilterConfig(val) {
-    return val != null && typeof val === 'object' && 'type' in val;
-}
-/** Resolve the filter field key for a column (filterField or columnId). */
-export function getFilterField(col) {
-    const f = isFilterConfig(col.filterable) ? col.filterable : null;
-    return (f?.filterField ?? col.columnId);
-}
-/** Merge a single filter change into a full IFilters object. Strips empty values automatically. */
-export function mergeFilter(prev, key, value) {
-    const isEmpty = value === undefined ||
-        (value.type === 'text' && value.value.trim() === '') ||
-        (value.type === 'multiSelect' && value.value.length === 0) ||
-        (value.type === 'date' && !value.value.from && !value.value.to) ||
-        (value.type === 'people' && !value.value);
-    if (isEmpty) {
-        const { [key]: _, ...rest } = prev;
-        return rest;
-    }
-    return { ...prev, [key]: value };
-}
-/** Derive filter options for multiSelect columns from client-side data. */
-export function deriveFilterOptionsFromData(items, columns) {
-    // Collect multiSelect columns upfront
-    const filterCols = [];
-    for (let i = 0; i < columns.length; i++) {
-        const col = columns[i];
-        const f = isFilterConfig(col.filterable) ? col.filterable : null;
-        if (f?.type === 'multiSelect') {
-            filterCols.push({ col, field: getFilterField(col) });
-        }
-    }
-    if (filterCols.length === 0)
-        return {};
-    // Single pass through items, collecting values for all filter columns simultaneously
-    const valueSets = new Map();
-    for (let i = 0; i < filterCols.length; i++) {
-        valueSets.set(filterCols[i].field, new Set());
-    }
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        for (let j = 0; j < filterCols.length; j++) {
-            const v = getCellValue(item, filterCols[j].col);
-            const set = valueSets.get(filterCols[j].field);
-            if (v != null && v !== '' && set)
-                set.add(String(v));
-        }
-    }
-    const out = {};
-    for (let i = 0; i < filterCols.length; i++) {
-        const set = valueSets.get(filterCols[i].field);
-        out[filterCols[i].field] = set ? Array.from(set).sort() : [];
-    }
-    return out;
-}
-/** Get list of filter fields that use multiSelect (for useFilterOptions). */
-export function getMultiSelectFilterFields(columns) {
-    const fields = [];
-    for (const col of columns) {
-        const f = isFilterConfig(col.filterable) ? col.filterable : null;
-        if (f?.type === 'multiSelect')
-            fields.push(getFilterField(col));
-    }
-    return fields;
-}

package/dist/esm/utils/paginationHelpers.js

@@ -1,58 +0,0 @@
-/**
- * Shared pagination view model for Fluent, Material, and Radix PaginationControls.
- * UI packages use this and render only presentation.
- */
-export const PAGE_SIZE_OPTIONS = [10, 25, 50, 100];
-/** Ensures the active pageSize is included in the options list, inserting it in sorted order if missing. */
-function ensurePageSizeInOptions(pageSize, options) {
-    if (options.includes(pageSize))
-        return options;
-    return [...options, pageSize].sort((a, b) => a - b);
-}
-export const MAX_PAGE_BUTTONS = 5;
-/**
- * Returns a view model for pagination UI. Use in Fluent/Material/Radix PaginationControls
- * so page math lives in one place and components only render.
- */
-export function getPaginationViewModel(currentPage, pageSize, totalCount, options) {
-    if (totalCount <= 0)
-        return null;
-    const maxPageButtons = options?.maxPageButtons ?? MAX_PAGE_BUTTONS;
-    const totalPages = Math.ceil(totalCount / pageSize);
-    let pageNumbers;
-    let showStartEllipsis;
-    let showEndEllipsis;
-    if (totalPages <= maxPageButtons) {
-        pageNumbers = [];
-        for (let i = 1; i <= totalPages; i++)
-            pageNumbers.push(i);
-        showStartEllipsis = false;
-        showEndEllipsis = false;
-    }
-    else {
-        let start = Math.max(1, currentPage - 2);
-        let end = Math.min(totalPages, currentPage + 2);
-        if (end - start + 1 < maxPageButtons) {
-            if (start === 1)
-                end = Math.min(totalPages, start + maxPageButtons - 1);
-            else if (end === totalPages)
-                start = Math.max(1, end - maxPageButtons + 1);
-        }
-        pageNumbers = [];
-        for (let i = start; i <= end; i++)
-            pageNumbers.push(i);
-        showStartEllipsis = start > 1;
-        showEndEllipsis = end < totalPages;
-    }
-    const startItem = Math.max(1, (currentPage - 1) * pageSize + 1);
-    const endItem = Math.min(currentPage * pageSize, totalCount);
-    return {
-        totalPages,
-        pageNumbers,
-        showStartEllipsis,
-        showEndEllipsis,
-        startItem,
-        endItem,
-        pageSizeOptions: ensurePageSizeInOptions(pageSize, options?.pageSizeOptions ?? PAGE_SIZE_OPTIONS),
-    };
-}

package/dist/esm/utils/selectionHelpers.js

@@ -1,94 +0,0 @@
-// Re-export normalizeSelectionRange from its canonical location for convenience.
-// The original definition lives in dataGridTypes.ts and is preserved there
-// to avoid breaking existing imports.
-export { normalizeSelectionRange } from '../types/dataGridTypes';
-/**
- * Compare two selection ranges by value (deep equality).
- * Returns true if both ranges are equal, including when both are null.
- */
-export function rangesEqual(a, b) {
-    if (a === b)
-        return true;
-    if (!a || !b)
-        return false;
-    return (a.startRow === b.startRow &&
-        a.endRow === b.endRow &&
-        a.startCol === b.startCol &&
-        a.endCol === b.endCol);
-}
-/**
- * Clamp a selection range to the grid bounds (0-based, inclusive).
- *
- * @param range         The selection range to clamp.
- * @param maxRow        Maximum valid row index (items.length - 1).
- * @param maxCol        Maximum valid column index (visibleCols.length - 1).
- * @returns The clamped range, or null if the grid is empty.
- */
-export function clampSelectionToBounds(range, maxRow, maxCol) {
-    if (maxRow < 0 || maxCol < 0)
-        return null;
-    return {
-        startRow: Math.max(0, Math.min(range.startRow, maxRow)),
-        endRow: Math.max(0, Math.min(range.endRow, maxRow)),
-        startCol: Math.max(0, Math.min(range.startCol, maxCol)),
-        endCol: Math.max(0, Math.min(range.endCol, maxCol)),
-    };
-}
-/**
- * Auto-scroll speed: proportional to how far past the scroll edge the pointer is.
- * Used by drag-selection auto-scroll in both React and Vue.
- *
- * @param distance  Distance past the edge threshold (pixels).
- * @param edgePx    Scroll edge threshold in pixels (default: 40).
- * @param minSpeed  Minimum scroll speed (default: 2).
- * @param maxSpeed  Maximum scroll speed (default: 20).
- * @returns Scroll speed in pixels per interval tick.
- */
-export function computeAutoScrollSpeed(distance, edgePx = 40, minSpeed = 2, maxSpeed = 20) {
-    const t = Math.min(distance / edgePx, 1);
-    return minSpeed + t * (maxSpeed - minSpeed);
-}
-/**
- * Apply a shift-click range selection to a set of row IDs.
- * Used by React `useRowSelection`, Vue `useRowSelection`, and JS `RowSelectionState`.
- *
- * @param start       Start index of the range (inclusive).
- * @param end         End index of the range (inclusive).
- * @param checked     Whether to add (true) or remove (false) the rows.
- * @param items       Array of all row data objects.
- * @param getRowId    Function to extract a unique row ID from an item.
- * @param currentSelection  Current set of selected row IDs (will be shallow-copied).
- * @returns A new Set of selected row IDs after applying the range.
- */
-export function applyRangeRowSelection(start, end, checked, items, getRowId, currentSelection) {
-    const next = new Set(currentSelection);
-    const lo = Math.min(start, end);
-    const hi = Math.max(start, end);
-    for (let i = lo; i <= hi; i++) {
-        if (i < items.length) {
-            const id = getRowId(items[i]);
-            if (checked)
-                next.add(id);
-            else
-                next.delete(id);
-        }
-    }
-    return next;
-}
-/**
- * Compute the allSelected / someSelected state from a set of selected row IDs.
- * Used by React `useRowSelection`, Vue `useRowSelection`, and JS `RowSelectionState`.
- *
- * @param selectedIds  Current set of selected row IDs.
- * @param items        Array of all row data objects.
- * @param getRowId     Function to extract a unique row ID from an item.
- * @returns An object with `allSelected` and `someSelected` booleans.
- */
-export function computeRowSelectionState(selectedIds, items, getRowId) {
-    if (selectedIds.size === 0 || items.length === 0) {
-        return { allSelected: false, someSelected: false };
-    }
-    const allSelected = items.every((item) => selectedIds.has(getRowId(item)));
-    const someSelected = !allSelected && selectedIds.size > 0;
-    return { allSelected, someSelected };
-}

package/dist/esm/utils/sortHelpers.js

@@ -1,28 +0,0 @@
-/**
- * Sort state computation helpers shared across all frameworks.
- */
-/**
- * Compute the next sort state given the current state and a sort request.
- *
- * @param current - Current sort state
- * @param columnKey - Column being sorted
- * @param direction - Explicit direction, `null` to clear, or `undefined` to toggle
- * @returns New sort state
- */
-export function computeNextSortState(current, columnKey, direction) {
-    if (direction === null) {
-        // Clear sort
-        return { field: '', direction: 'asc' };
-    }
-    else if (direction) {
-        // Explicit direction (from column menu)
-        return { field: columnKey, direction };
-    }
-    else {
-        // Toggle (existing behavior for header click)
-        return {
-            field: columnKey,
-            direction: current.field === columnKey && current.direction === 'asc' ? 'desc' : 'asc',
-        };
-    }
-}

package/dist/esm/utils/statusBarHelpers.js

@@ -1,27 +0,0 @@
-/**
- * Returns an array of status bar parts (Rows, Filtered, Selected) for consistent rendering across packages.
- */
-export function getStatusBarParts(input) {
-    const { totalCount, filteredCount, selectedCount, selectedCellCount, aggregation, suppressRowCount } = input;
-    const parts = [];
-    if (!suppressRowCount) {
-        parts.push({ key: 'total', label: 'Rows:', value: totalCount });
-    }
-    if (filteredCount !== undefined && filteredCount !== totalCount) {
-        parts.push({ key: 'filtered', label: 'Filtered:', value: filteredCount });
-    }
-    if (selectedCount !== undefined && selectedCount > 0) {
-        parts.push({ key: 'selected', label: 'Selected:', value: selectedCount });
-    }
-    if (selectedCellCount !== undefined && selectedCellCount > 1) {
-        parts.push({ key: 'cells', label: 'Cells:', value: selectedCellCount });
-    }
-    if (aggregation) {
-        parts.push({ key: 'sum', label: 'Sum:', value: aggregation.sum });
-        parts.push({ key: 'avg', label: 'Avg:', value: Math.round(aggregation.avg * 100) / 100 });
-        parts.push({ key: 'min', label: 'Min:', value: aggregation.min });
-        parts.push({ key: 'max', label: 'Max:', value: aggregation.max });
-        parts.push({ key: 'count', label: 'Count:', value: aggregation.count });
-    }
-    return parts;
-}