@opencorestack/opengridx 0.1.6 → 0.1.8

package/lib/utils/filtering/index.ts

@@ -0,0 +1,240 @@
+
+import type { GridRowModel, GridFilterItem, GridFilterModel, GridFilterGroup } from '../../types';
+
+export const FILTER_OPERATORS = {
+  contains: (value: any, filterValue: any): boolean => {
+    if (value == null || filterValue == null) return false;
+    return String(value).toLowerCase().includes(String(filterValue).toLowerCase());
+  },
+
+  equals: (value: any, filterValue: any): boolean => {
+    if (value == null && filterValue == null) return true;
+    if (value == null || filterValue == null) return false;
+    return String(value).toLowerCase() === String(filterValue).toLowerCase();
+  },
+
+  startsWith: (value: any, filterValue: any): boolean => {
+    if (value == null || filterValue == null) return false;
+    return String(value).toLowerCase().startsWith(String(filterValue).toLowerCase());
+  },
+
+  endsWith: (value: any, filterValue: any): boolean => {
+    if (value == null || filterValue == null) return false;
+    return String(value).toLowerCase().endsWith(String(filterValue).toLowerCase());
+  },
+
+  isEmpty: (value: any): boolean => {
+    return value == null || String(value).trim() === '';
+  },
+
+  isNotEmpty: (value: any): boolean => {
+    return value != null && String(value).trim() !== '';
+  },
+
+  '>': (value: any, filterValue: any): boolean => {
+    if (value == null || filterValue == null) return false;
+    const numValue = Number(value);
+    const numFilter = Number(filterValue);
+    if (isNaN(numValue) || isNaN(numFilter)) return false;
+    return numValue > numFilter;
+  },
+
+  '>=': (value: any, filterValue: any): boolean => {
+    if (value == null || filterValue == null) return false;
+    const numValue = Number(value);
+    const numFilter = Number(filterValue);
+    if (isNaN(numValue) || isNaN(numFilter)) return false;
+    return numValue >= numFilter;
+  },
+
+  '<': (value: any, filterValue: any): boolean => {
+    if (value == null || filterValue == null) return false;
+    const numValue = Number(value);
+    const numFilter = Number(filterValue);
+    if (isNaN(numValue) || isNaN(numFilter)) return false;
+    return numValue < numFilter;
+  },
+
+  '<=': (value: any, filterValue: any): boolean => {
+    if (value == null || filterValue == null) return false;
+    const numValue = Number(value);
+    const numFilter = Number(filterValue);
+    if (isNaN(numValue) || isNaN(numFilter)) return false;
+    return numValue <= numFilter;
+  },
+
+  '!=': (value: any, filterValue: any): boolean => {
+    if (filterValue == null || filterValue === '') return true;
+    // Numeric comparison if both are numbers, otherwise string
+    const numV = Number(value);
+    const numF = Number(filterValue);
+    if (!isNaN(numV) && !isNaN(numF)) return numV !== numF;
+    return String(value).toLowerCase() !== String(filterValue).toLowerCase();
+  },
+
+  isAnyOf: (value: any, filterValue: any[]): boolean => {
+    if (value == null || !Array.isArray(filterValue)) return false;
+    return filterValue.some(v => 
+      String(value).toLowerCase() === String(v).toLowerCase()
+    );
+  },
+
+  not: (value: any, filterValue: any): boolean => {
+      if (value == null && filterValue == null) return false;
+      if (value == null || filterValue == null) return true;
+      return String(value).toLowerCase() !== String(filterValue).toLowerCase();
+  },
+
+  // Used by boolean and singleSelect — case-insensitive string comparison
+  is: (value: any, filterValue: any): boolean => {
+      if (filterValue == null || filterValue === '') return true;
+      const rowStr = String(value).toLowerCase();
+      const filterStr = String(filterValue).toLowerCase();
+      return rowStr === filterStr;
+  },
+
+  '=': (value: any, filterValue: any): boolean => {
+      if (value == null || filterValue == null || filterValue === '') return false;
+      return Number(value) === Number(filterValue);
+  },
+};
+
+/**
+ * Apply a single filter item to a row
+ */
+export function applyFilterItem<R extends GridRowModel>(
+  row: R,
+  filterItem: GridFilterItem
+): boolean {
+  const { field, operator, value } = filterItem;
+
+  // Get the value from the row
+  const rowValue = row[field];
+
+  // Get the operator function
+  const operatorFn = FILTER_OPERATORS[operator];
+  if (!operatorFn) {
+    console.warn(`Unknown filter operator: ${operator}`);
+    return true;
+  }
+
+  // Apply the operator
+  return operatorFn(rowValue, value);
+}
+
+/**
+ * Apply quick filter (global search across all fields)
+ */
+export function applyQuickFilter<R extends GridRowModel>(
+  row: R,
+  quickFilterValues: string[]
+): boolean {
+  if (!quickFilterValues || quickFilterValues.length === 0) {
+    return true;
+  }
+
+  // Check if any quick filter value matches any field in the row
+  return quickFilterValues.every(filterValue => {
+    const searchTerm = filterValue.toLowerCase();
+    return Object.values(row).some(value => {
+      if (value == null) return false;
+      return String(value).toLowerCase().includes(searchTerm);
+    });
+  });
+}
+
+/**
+ * Filter rows based on filter model
+ */
+/**
+ * Check if a row matches the filter model
+ */
+export function isRowMatchingFilter<R extends GridRowModel>(
+  row: R,
+  filterModel: GridFilterModel | GridFilterGroup // Accept Model or Group (similar structure)
+): boolean {
+  // Normalize input: GridFilterModel matches GridFilterGroup shape largely, but let's be safe
+
+  const items = (filterModel as any).items || [];
+  const logicOperator = (filterModel as any).logicOperator || 'and';
+  const quickFilterValues = (filterModel as any).quickFilterValues || [];
+
+  if (quickFilterValues.length > 0 && !applyQuickFilter(row, quickFilterValues)) {
+    return false;
+  }
+
+  if (items.length === 0) {
+    return true;
+  }
+
+  const evaluateItem = (item: GridFilterItem | GridFilterGroup): boolean => {
+    if ('logicOperator' in item && 'items' in item) {
+
+       const group = item as GridFilterGroup;
+       const groupItems = group.items;
+       if (groupItems.length === 0) return true;
+
+       if (group.logicOperator === 'and') {
+           return groupItems.every(evaluateItem);
+       } else {
+           return groupItems.some(evaluateItem);
+       }
+    } else {
+
+       return applyFilterItem(row, item as GridFilterItem);
+    }
+  };
+
+  if (logicOperator === 'and') {
+
+    return items.every(evaluateItem);
+  } else {
+
+    return items.some(evaluateItem);
+  }
+}
+
+export function filterRows<R extends GridRowModel>(
+  rows: R[],
+  filterModel: GridFilterModel
+): R[] {
+  if (!filterModel) return rows;
+
+  const { items = [], quickFilterValues = [] } = filterModel;
+
+  if (items.length === 0 && (!quickFilterValues || quickFilterValues.length === 0)) {
+    return rows;
+  }
+
+  return rows.filter(row => isRowMatchingFilter(row, filterModel));
+}
+
+export function getDefaultOperator(type?: string): string {
+  switch (type) {
+    case 'number':
+      return '=';
+    case 'date':
+      return 'is';
+    case 'boolean':
+      return 'is';
+    case 'singleSelect':
+      return 'isAnyOf';
+    default:
+      return 'contains';
+  }
+}
+
+export function getOperatorsForType(type?: string): string[] {
+  switch (type) {
+    case 'number':
+      return ['=', '!=', '>', '>=', '<', '<=', 'isEmpty', 'isNotEmpty'];
+    case 'date':
+      return ['is', 'not', 'after', 'onOrAfter', 'before', 'onOrBefore', 'isEmpty', 'isNotEmpty'];
+    case 'boolean':
+      return ['is'];
+    case 'singleSelect':
+      return ['isAnyOf', 'is', 'not'];
+    default:
+      return ['contains', 'equals', 'startsWith', 'endsWith', 'isEmpty', 'isNotEmpty'];
+  }
+}

package/lib/utils/pinning/index.ts

@@ -0,0 +1,282 @@
+
+import type { GridColDef, GridRowModel, GridColumnPinning, GridRowPinning, GridPinnedPosition, GridRowId } from '../../types';
+
+export function isColumnPinned(field: string, pinnedColumns?: GridColumnPinning): GridPinnedPosition | null {
+    if (!pinnedColumns) return null;
+
+    if (pinnedColumns.left?.includes(field)) {
+        return 'left';
+    }
+
+    if (pinnedColumns.right?.includes(field)) {
+        return 'right';
+    }
+
+    return null;
+}
+
+export function getPinnedColumnGroups<R extends GridRowModel = GridRowModel>(
+    columns: GridColDef<R>[],
+    pinnedColumns?: GridColumnPinning
+): {
+    left: GridColDef<R>[];
+    center: GridColDef<R>[];
+    right: GridColDef<R>[];
+} {
+    const left: GridColDef<R>[] = [];
+    const center: GridColDef<R>[] = [];
+    const right: GridColDef<R>[] = [];
+
+    if (!pinnedColumns) {
+        return { left, center: columns, right };
+    }
+
+    columns.forEach(col => {
+        const pinnedPosition = isColumnPinned(col.field, pinnedColumns);
+
+        if (pinnedPosition === 'left') {
+            left.push(col);
+        } else if (pinnedPosition === 'right') {
+            right.push(col);
+        } else {
+            center.push(col);
+        }
+    });
+
+    if (pinnedColumns.left) {
+        left.sort((a, b) => {
+            const aIndex = pinnedColumns.left!.indexOf(a.field);
+            const bIndex = pinnedColumns.left!.indexOf(b.field);
+            return aIndex - bIndex;
+        });
+    }
+
+    if (pinnedColumns.right) {
+        right.sort((a, b) => {
+            const aIndex = pinnedColumns.right!.indexOf(a.field);
+            const bIndex = pinnedColumns.right!.indexOf(b.field);
+            return aIndex - bIndex;
+        });
+    }
+
+    return { left, center, right };
+}
+
+export function calculatePinnedPositions<R extends GridRowModel = GridRowModel>(
+    columns: GridColDef<R>[],
+    columnWidths: Record<string, number>,
+    pinnedColumns?: GridColumnPinning,
+    checkboxSelection?: boolean,
+    pinCheckboxColumn?: boolean,
+    hasDetailPanel?: boolean,
+    pinExpandColumn?: boolean,
+    rowReordering?: boolean
+): Record<string, number> {
+    const positions: Record<string, number> = {};
+
+    if (!pinnedColumns) return positions;
+
+    const groups = getPinnedColumnGroups(columns, pinnedColumns);
+
+    let leftOffset = 0;
+
+    if (rowReordering) {
+        leftOffset += 48;
+    }
+
+    if (hasDetailPanel && pinExpandColumn) {
+        leftOffset += 48; 
+    }
+
+    if (checkboxSelection && pinCheckboxColumn) {
+        leftOffset += 48; 
+    }
+
+    groups.left.forEach(col => {
+        positions[col.field] = leftOffset;
+        const width = columnWidths[col.field] ?? col.width ?? 100;
+        leftOffset += width;
+    });
+
+    let rightOffset = 0;
+
+    [...groups.right].reverse().forEach(col => {
+        const width = columnWidths[col.field] ?? col.width ?? 100;
+        positions[col.field] = rightOffset;
+        rightOffset += width;
+    });
+
+    return positions;
+}
+
+export function isColumnPinnable<R extends GridRowModel = GridRowModel>(
+    colDef: GridColDef<R>
+): boolean {
+    return colDef.pinnable !== false;
+}
+
+export function pinColumn(
+    field: string,
+    position: GridPinnedPosition,
+    currentPinning?: GridColumnPinning
+): GridColumnPinning {
+    const newPinning: GridColumnPinning = {
+        left: [...(currentPinning?.left || [])],
+        right: [...(currentPinning?.right || [])]
+    };
+
+    newPinning.left = (newPinning.left || []).filter(f => f !== field);
+    newPinning.right = (newPinning.right || []).filter(f => f !== field);
+
+    if (position === 'left') {
+        if (!newPinning.left) newPinning.left = [];
+        newPinning.left.push(field);
+    } else {
+        if (!newPinning.right) newPinning.right = [];
+        newPinning.right.push(field);
+    }
+
+    return newPinning;
+}
+
+export function unpinColumn(
+    field: string,
+    currentPinning?: GridColumnPinning
+): GridColumnPinning {
+    if (!currentPinning) return {};
+
+    return {
+        left: currentPinning.left?.filter(f => f !== field) || [],
+        right: currentPinning.right?.filter(f => f !== field) || []
+    };
+}
+
+export function getPinnedColumnsWidth(
+    columns: GridColDef[],
+    columnWidths: Record<string, number>,
+    position: GridPinnedPosition,
+    pinnedColumns?: GridColumnPinning
+): number {
+    if (!pinnedColumns) return 0;
+
+    const pinnedFields = position === 'left' ? pinnedColumns.left : pinnedColumns.right;
+    if (!pinnedFields) return 0;
+
+    return pinnedFields.reduce((total, field) => {
+        const col = columns.find(c => c.field === field);
+        if (!col) return total;
+
+        const width = columnWidths[field] ?? col.width ?? 100;
+        return total + width;
+    }, 0);
+}
+
+export function isRowPinned(
+    rowId: GridRowId,
+    pinnedRows?: GridRowPinning
+): 'top' | 'bottom' | null {
+    if (!pinnedRows) return null;
+
+    if (pinnedRows.top?.includes(rowId)) {
+        return 'top';
+    }
+
+    if (pinnedRows.bottom?.includes(rowId)) {
+        return 'bottom';
+    }
+
+    return null;
+}
+
+export function getPinnedRowGroups<R extends GridRowModel = GridRowModel>(
+    rows: R[],
+    pinnedRows?: GridRowPinning
+): {
+    top: R[];
+    center: R[];
+    bottom: R[];
+} {
+    const top: R[] = [];
+    const center: R[] = [];
+    const bottom: R[] = [];
+
+    if (!pinnedRows) {
+        return { top, center: rows, bottom };
+    }
+
+    rows.forEach(row => {
+        const pinnedPosition = isRowPinned(row.id, pinnedRows);
+
+        if (pinnedPosition === 'top') {
+            top.push(row);
+        } else if (pinnedPosition === 'bottom') {
+            bottom.push(row);
+        } else {
+            center.push(row);
+        }
+    });
+
+    if (pinnedRows.top) {
+        top.sort((a, b) => {
+            const aIndex = pinnedRows.top!.indexOf(a.id);
+            const bIndex = pinnedRows.top!.indexOf(b.id);
+            return aIndex - bIndex;
+        });
+    }
+
+    if (pinnedRows.bottom) {
+        bottom.sort((a, b) => {
+            const aIndex = pinnedRows.bottom!.indexOf(a.id);
+            const bIndex = pinnedRows.bottom!.indexOf(b.id);
+            return aIndex - bIndex;
+        });
+    }
+
+    return { top, center, bottom };
+}
+
+export function pinRow(
+    rowId: GridRowId,
+    position: 'top' | 'bottom',
+    currentPinning?: GridRowPinning
+): GridRowPinning {
+    const newPinning: GridRowPinning = {
+        top: [...(currentPinning?.top || [])],
+        bottom: [...(currentPinning?.bottom || [])]
+    };
+
+    newPinning.top = (newPinning.top || []).filter(id => id !== rowId);
+    newPinning.bottom = (newPinning.bottom || []).filter(id => id !== rowId);
+
+    if (position === 'top') {
+        if (!newPinning.top) newPinning.top = [];
+        newPinning.top.push(rowId);
+    } else {
+        if (!newPinning.bottom) newPinning.bottom = [];
+        newPinning.bottom.push(rowId);
+    }
+
+    return newPinning;
+}
+
+export function unpinRow(
+    rowId: GridRowId,
+    currentPinning?: GridRowPinning
+): GridRowPinning {
+    if (!currentPinning) return {};
+
+    return {
+        top: currentPinning.top?.filter(id => id !== rowId) || [],
+        bottom: currentPinning.bottom?.filter(id => id !== rowId) || []
+    };
+}
+
+export function getPinnedRowsCount(
+    position: 'top' | 'bottom',
+    pinnedRows?: GridRowPinning
+): number {
+    if (!pinnedRows) return 0;
+
+    const pinnedIds = position === 'top' ? pinnedRows.top : pinnedRows.bottom;
+    return pinnedIds?.length || 0;
+}

package/lib/utils/sorting/index.ts

@@ -0,0 +1,55 @@
+
+import type { GridRowModel, GridSortItem } from '../../types';
+
+export function compareValues(a: any, b: any, direction: 'asc' | 'desc'): number {
+
+  if (a == null && b == null) return 0;
+  if (a == null) return direction === 'asc' ? 1 : -1;
+  if (b == null) return direction === 'asc' ? -1 : 1;
+
+  if (typeof a === 'number' && typeof b === 'number') {
+    return direction === 'asc' ? a - b : b - a;
+  }
+
+  if (a instanceof Date && b instanceof Date) {
+    return direction === 'asc' 
+      ? a.getTime() - b.getTime() 
+      : b.getTime() - a.getTime();
+  }
+
+  const aStr = String(a).toLowerCase();
+  const bStr = String(b).toLowerCase();
+
+  if (direction === 'asc') {
+    return aStr < bStr ? -1 : aStr > bStr ? 1 : 0;
+  } else {
+    return aStr > bStr ? -1 : aStr < bStr ? 1 : 0;
+  }
+}
+
+export function sortRows<R extends GridRowModel>(
+  rows: R[],
+  sortModel: GridSortItem[]
+): R[] {
+  if (sortModel.length === 0) {
+    return rows;
+  }
+
+  const sortedRows = [...rows];
+
+  sortedRows.sort((a, b) => {
+    for (const sortItem of sortModel) {
+      const aValue = a[sortItem.field];
+      const bValue = b[sortItem.field];
+
+      const comparison = compareValues(aValue, bValue, sortItem.sort);
+
+      if (comparison !== 0) {
+        return comparison;
+      }
+    }
+    return 0;
+  });
+
+  return sortedRows;
+}

package/lib/utils/virtualization/index.ts

@@ -0,0 +1,106 @@
+
+import { GridRenderContext } from '../../types';
+
+export interface VirtualizationParams {
+  scrollTop: number;
+  scrollLeft: number;
+  viewportHeight: number;
+  viewportWidth: number;
+  rowHeight: number;
+  totalRows: number;
+  columnWidths: number[];
+  overscan?: number;
+}
+
+export interface VirtualizationResult {
+  renderContext: GridRenderContext;
+  offsetTop: number;
+  offsetLeft: number;
+  totalHeight: number;
+  totalWidth: number;
+}
+
+export function calculateVirtualization(params: VirtualizationParams): VirtualizationResult {
+  const {
+    scrollTop,
+    scrollLeft,
+    viewportHeight,
+    viewportWidth,
+    rowHeight,
+    totalRows,
+    columnWidths,
+    overscan = 3
+  } = params;
+
+  const firstVisibleRow = Math.floor(scrollTop / rowHeight);
+  const lastVisibleRow = Math.min(
+    totalRows - 1,
+    Math.ceil((scrollTop + viewportHeight) / rowHeight)
+  );
+
+  const firstRowIndex = Math.max(0, firstVisibleRow - overscan);
+  const lastRowIndex = Math.min(totalRows - 1, lastVisibleRow + overscan);
+
+  let accumulatedWidth = 0;
+  let firstColumnIndex = 0;
+  let lastColumnIndex = columnWidths.length - 1;
+  let offsetLeft = 0;
+
+  for (let i = 0; i < columnWidths.length; i++) {
+    if (accumulatedWidth + columnWidths[i] > scrollLeft) {
+      firstColumnIndex = Math.max(0, i - overscan);
+      break;
+    }
+    accumulatedWidth += columnWidths[i];
+  }
+
+  offsetLeft = columnWidths.slice(0, firstColumnIndex).reduce((sum, width) => sum + width, 0);
+
+  accumulatedWidth = offsetLeft;
+  for (let i = firstColumnIndex; i < columnWidths.length; i++) {
+    accumulatedWidth += columnWidths[i];
+    if (accumulatedWidth >= scrollLeft + viewportWidth) {
+      lastColumnIndex = Math.min(columnWidths.length - 1, i + overscan);
+      break;
+    }
+  }
+
+  const totalHeight = totalRows * rowHeight;
+  const totalWidth = columnWidths.reduce((sum, width) => sum + width, 0);
+  const offsetTop = firstRowIndex * rowHeight;
+
+  return {
+    renderContext: {
+      firstRowIndex,
+      lastRowIndex,
+      firstColumnIndex,
+      lastColumnIndex
+    },
+    offsetTop,
+    offsetLeft,
+    totalHeight,
+    totalWidth
+  };
+}
+
+export function getRowPosition(rowIndex: number, rowHeight: number): number {
+  return rowIndex * rowHeight;
+}
+
+export function getColumnPosition(colIndex: number, columnWidths: number[]): number {
+  return columnWidths.slice(0, colIndex).reduce((sum, width) => sum + width, 0);
+}
+
+export function isRowVisible(
+  rowIndex: number,
+  renderContext: GridRenderContext
+): boolean {
+  return rowIndex >= renderContext.firstRowIndex && rowIndex <= renderContext.lastRowIndex;
+}
+
+export function isColumnVisible(
+  colIndex: number,
+  renderContext: GridRenderContext
+): boolean {
+  return colIndex >= renderContext.firstColumnIndex && colIndex <= renderContext.lastColumnIndex;
+}

package/lib/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/llms.txt

@@ -1,6 +1,6 @@
 # OpenGridX — AI Agent Context
 # Package: @opencorestack/opengridx
-# Version: 0.1.6
+# Version: 0.1.7
 # Docs: https://opencorestack.github.io/OpenGridX/
 # This file is machine-readable. AI developers: start here.
 
@@ -234,6 +234,7 @@ export default function App() {
 | resizable         | boolean (default true)                                 | Enable resize handle                       |
 | hideable          | boolean (default true)                                 | Allow hiding via toolbar                   |
 | pinnable          | boolean (default true)                                 | Allow pinning via column menu              |
+| exportable        | boolean (default true)                                 | Include in CSV/Excel/JSON/Print exports    |
 | disableColumnMenu | boolean                                                | Hide the ⋮ column menu button             |
 
 ---