const filterObjects = (array, filters) => {
  // Validate inputs
  if (!Array.isArray(array)) {
    throw new Error('First argument must be an array');
  }
  
  if (filters && typeof filters !== 'object') {
    throw new Error('Filters must be an object');
  }
  
  // If no filters provided, return original array
  if (!filters || Object.keys(filters).length === 0) {
    return array;
  }
  
  // Perform filtering
  return array.filter(item => {
    return Object.entries(filters).every(([key, value]) => {
      if (value instanceof RegExp) {
        return value.test(item[key]);
      }
      
      if (typeof value === 'function') {
        return value(item[key]);
      }
      
      return item[key] === value;
    });
  });
};

import aiohttp
import json
from typing import Dict, Any, Optional, Union

class APIClient:
    """A simple async HTTP API client."""
    
    def __init__(self, base_url: str, headers: Optional[Dict[str, str]] = None):
        """
        Initialize the API client.
        
        Args:
            base_url: The base URL for the API
            headers: Optional default headers for all requests
        """
        self.base_url = base_url.rstrip('/')
        self.headers = headers or {}
        self._session = None
    
    async def __aenter__(self):
        if self._session is None:
            self._session = aiohttp.ClientSession(headers=self.headers)
        return self
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self._session:
            await self._session.close()
            self._session = None
    
    async def request(
        self,
        method: str,
        endpoint: str,
        params: Optional[Dict[str, Any]] = None,
        data: Optional[Dict[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
    ) -> Dict[str, Any]:
        """
        Make an HTTP request to the API.
        
        Args:
            method: HTTP method (GET, POST, etc.)
            endpoint: API endpoint (will be appended to base_url)
            params: Optional query parameters
            data: Optional request body data
            headers: Optional headers to override defaults
            
        Returns:
            Parsed JSON response as a dictionary
        """
        if self._session is None:
            raise RuntimeError("Client must be used as an async context manager")
            
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        merged_headers = {**self.headers, **(headers or {})}
        
        async with self._session.request(
            method=method,
            url=url,
            params=params,
            json=data,
            headers=merged_headers,
        ) as response:
            response_data = await response.json()
            response.raise_for_status()
            return response_data
    
    async def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None, **kwargs) -> Dict[str, Any]:
        return await self.request("GET", endpoint, params=params, **kwargs)
    
    async def post(self, endpoint: str, data: Optional[Dict[str, Any]] = None, **kwargs) -> Dict[str, Any]:
        return await self.request("POST", endpoint, data=data, **kwargs)

import React, { useState, useMemo } from 'react';

// Define types
type SortDirection = 'asc' | 'desc';

interface Column {
  key: keyof T;
  header: string;
  sortable?: boolean;
  render?: (item: T) => React.ReactNode;
}

interface DataTableProps {
  data: T[];
  columns: Column[];
  itemsPerPage?: number;
  className?: string;
}

const DataTable = >(
  { data, columns, itemsPerPage = 10, className = '' }: DataTableProps
) => {
  // State for sorting and pagination
  const [sortKey, setSortKey] = useState(null);
  const [sortDirection, setSortDirection] = useState('asc');
  const [currentPage, setCurrentPage] = useState(1);
  
  // Handle sorting
  const handleSort = (key: keyof T) => {
    if (sortKey === key) {
      setSortDirection(sortDirection === 'asc' ? 'desc' : 'asc');
    } else {
      setSortKey(key);
      setSortDirection('asc');
    }
  };
  
  // Calculate sorted and paginated data
  const processedData = useMemo(() => {
    // Sort data if sortKey is provided
    let sortedData = [...data];
    if (sortKey) {
      sortedData.sort((a, b) => {
        const valueA = a[sortKey];
        const valueB = b[sortKey];
        
        if (valueA < valueB) return sortDirection === 'asc' ? -1 : 1;
        if (valueA > valueB) return sortDirection === 'asc' ? 1 : -1;
        return 0;
      });
    }
    
    // Apply pagination
    const startIndex = (currentPage - 1) * itemsPerPage;
    const endIndex = startIndex + itemsPerPage;
    return sortedData.slice(startIndex, endIndex);
  }, [data, sortKey, sortDirection, currentPage, itemsPerPage]);
  
  // Calculate total pages
  const totalPages = Math.ceil(data.length / itemsPerPage);
  
  return (
    

      
            {columns.map((column) => (
              
            ))}
          
          {processedData.map((item, index) => (
            
              {columns.map((column) => (
                
              ))}
            
          ))}
        

        

          
 column.sortable && handleSort(column.key)}
              >
                

                  {column.header}
                  {column.sortable && sortKey === column.key && (
                    
                      {sortDirection === 'asc' ? '↑' : '↓'}
                    
                  )}
                
              
        
        

                  {column.render ? column.render(item) : item[column.key]}
                
      
      
      {totalPages > 1 && (
        

           setCurrentPage(prev => Math.max(prev - 1, 1))}
            disabled={currentPage === 1}
            className="px-4 py-2 border rounded text-sm disabled:opacity-50"
          >
            Previous
          
          
          
            Page {currentPage} of {totalPages}
          
          
           setCurrentPage(prev => Math.min(prev + 1, totalPages))}
            disabled={currentPage === totalPages}
            className="px-4 py-2 border rounded text-sm disabled:opacity-50"
          >
            Next
          
        
      )}
    
  );
};

export default DataTable;